@clawchatsai/connector 0.0.85 → 0.0.87

package/server.js

@@ -1,195 +1,144 @@
-// ClawChats Backend Server
-// Single-file Node.js HTTP server with SQLite storage
-// See specs/backend-session-architecture.md for full spec
-
-import http from 'node:http';
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { pipeline } from 'node:stream/promises';
-import { execSync } from 'node:child_process';
-import os from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { WebSocket as WS, WebSocketServer } from 'ws';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// ─── Native Module Bootstrap (better-sqlite3) ───────────────────────────────
-// better-sqlite3 is a native (.node) binary compiled for a specific Node.js
-// ABI. If the installed binary doesn't match the running Node version, we
-// auto-rebuild in-place before proceeding. Falls back to a clear error message
-// if the user is missing build tools.
-const _require = createRequire(import.meta.url);
-
-// Per-request workspace DB — isolates concurrent clients on different workspaces.
-const _requestDbStore = new AsyncLocalStorage();
-let Database;
-{
-  const _nativeErr = (e) =>
-    e.message && (
-      e.message.includes('did not self-register') ||
-      e.message.includes('NODE_MODULE_VERSION') ||
-      e.message.includes('was compiled against a different Node.js version')
-    );
-  try {
-    Database = _require('better-sqlite3');
-  } catch (e) {
-    if (_nativeErr(e)) {
-      console.error('[ClawChats] better-sqlite3 binary is incompatible with your Node.js version. Attempting auto-rebuild...');
-      try {
-        execSync('npm rebuild better-sqlite3', { cwd: __dirname, stdio: 'inherit' });
-        Database = _require('better-sqlite3');
-        console.log('[ClawChats] Auto-rebuild succeeded — continuing startup.');
-      } catch (rebuildErr) {
-        console.error('[ClawChats] Auto-rebuild failed. Build tools may be missing.');
-        console.error('[ClawChats] To fix, run the following, then restart the gateway:');
-        console.error(`[ClawChats]   cd ${__dirname} && npm rebuild better-sqlite3`);
-        console.error('[ClawChats] If that fails, install build tools first:');
-        console.error('[ClawChats]   Linux:  sudo apt install build-essential python3');
-        console.error('[ClawChats]   macOS:  xcode-select --install');
-        process.exit(1);
-      }
-    } else {
-      throw e;
+// ClawChats backend — built by esbuild, source: github.com/clawchatsai/connector
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// server/index.js
+import http from "node:http";
+import fs13 from "node:fs";
+import path14 from "node:path";
+import os5 from "node:os";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { WebSocket as WS2, WebSocketServer } from "ws";
+
+// server/bootstrap/native.js
+import { DatabaseSync as Database } from "node:sqlite";
+import { AsyncLocalStorage } from "node:async_hooks";
+var requestDbStore = new AsyncLocalStorage();
+
+// server/config.js
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+var HOME = os.homedir();
+var MAX_PREAMBLE_CHARS = 5e4;
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function parseConfigField(field) {
+  const candidates = [path.join(__dirname, "config.js"), path.join(__dirname, "..", "config.js")];
+  for (const configPath of candidates) {
+    try {
+      const configText = fs.readFileSync(configPath, "utf8");
+      const match = configText.match(new RegExp(`${field}:\\s*['"]([^'"]+)['"]`));
+      if (match) return match[1];
+    } catch {
     }
   }
+  return null;
 }
-
-// ─── Device Identity (ed25519 signing for OpenClaw ≥2.15 scope preservation) ─
-
-const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
-
-function _derivePublicKeyRaw(publicKeyPem) {
-  const spki = crypto.createPublicKey(publicKeyPem).export({ type: 'spki', format: 'der' });
-  if (spki.length === ED25519_SPKI_PREFIX.length + 32 &&
-      spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
-    return spki.subarray(ED25519_SPKI_PREFIX.length);
+__name(parseConfigField, "parseConfigField");
+var AUTH_TOKEN = process.env.CLAWCHATS_AUTH_TOKEN || parseConfigField("authToken") || "";
+function discoverGatewayWsUrl() {
+  if (process.env.GATEWAY_WS_URL) return process.env.GATEWAY_WS_URL;
+  for (const cfgPath of [path.join(HOME, ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
+    try {
+      const raw = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+      const port = raw.gateway?.port || raw.port;
+      const host = raw.gateway?.host || raw.host || "localhost";
+      if (port) return `ws://${host}:${port}`;
+    } catch {
+    }
   }
-  return spki;
-}
-
-function _fingerprintPublicKey(publicKeyPem) {
-  return crypto.createHash('sha256').update(_derivePublicKeyRaw(publicKeyPem)).digest('hex');
+  return "ws://localhost:18789";
 }
-
-function _base64UrlEncode(buf) {
-  return buf.toString('base64').replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/g, '');
-}
-
-function _loadOrCreateDeviceIdentity(identityPath) {
-  try {
-    if (fs.existsSync(identityPath)) {
-      const parsed = JSON.parse(fs.readFileSync(identityPath, 'utf8'));
-      if (parsed?.version === 1 && parsed.deviceId && parsed.publicKeyPem && parsed.privateKeyPem) return parsed;
-    }
-  } catch { /* regenerate */ }
-  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
-  const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' }).toString();
-  const privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
-  const identity = { version: 1, deviceId: _fingerprintPublicKey(publicKeyPem), publicKeyPem, privateKeyPem, createdAtMs: Date.now() };
-  fs.mkdirSync(path.dirname(identityPath), { recursive: true });
-  fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2) + '\n', { mode: 0o600 });
-  return identity;
+__name(discoverGatewayWsUrl, "discoverGatewayWsUrl");
+var GATEWAY_WS_URL = discoverGatewayWsUrl();
+var OPENCLAW_SESSIONS_DIR = process.env.OPENCLAW_SESSIONS_DIR || parseConfigField("sessionsDir") || path.join(HOME, ".openclaw", "agents", "main", "sessions");
+function getSessionsDirForAgent(agentId) {
+  if (!agentId || agentId === "main") return OPENCLAW_SESSIONS_DIR;
+  return path.join(HOME, ".openclaw", "agents", agentId, "sessions");
 }
-
-function _buildDeviceAuth(identity, { clientId, clientMode, role, scopes, token, nonce }) {
-  const signedAt = Date.now();
-  const payload = ['v2', identity.deviceId, clientId, clientMode, role, scopes.join(','), String(signedAt), token || '', nonce].join('|');
-  const privateKey = crypto.createPrivateKey(identity.privateKeyPem);
-  const signature = _base64UrlEncode(crypto.sign(null, Buffer.from(payload, 'utf8'), privateKey));
-  const publicKeyB64Url = _base64UrlEncode(_derivePublicKeyRaw(identity.publicKeyPem));
-  return { id: identity.deviceId, publicKey: publicKeyB64Url, signature, signedAt, nonce };
+__name(getSessionsDirForAgent, "getSessionsDirForAgent");
+function validateAgent(agentId) {
+  if (!agentId) return "main";
+  if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) throw new Error("Invalid agent ID");
+  const agentDir = path.join(HOME, ".openclaw", "agents", agentId);
+  if (!fs.existsSync(agentDir)) throw new Error(`Agent not found: ${agentId}`);
+  return agentId;
 }
+__name(validateAgent, "validateAgent");
 
-// ─── Configuration ──────────────────────────────────────────────────────────
-
-const PORT = parseInt(process.env.CLAWCHATS_PORT || process.env.SHELLCHAT_PORT || '3001', 10);
-const DATA_DIR = path.join(__dirname, 'data');
-const UPLOADS_DIR = path.join(__dirname, 'uploads');
-const WORKSPACES_FILE = path.join(DATA_DIR, 'workspaces.json');
-
-// --- Debug Recording (isolated module) ---
-class DebugLogger {
+// server/debug.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+var DebugLogger = class {
+  static {
+    __name(this, "DebugLogger");
+  }
   constructor(baseDir) {
-    this.baseDir = path.join(baseDir, '..', 'debug');
+    this.baseDir = path2.join(baseDir, "..", "debug");
     this.active = false;
     this.sessionId = null;
     this.wsStream = null;
     this.originatingClient = null;
   }
-
   start(ts, originatingClient) {
-    if (this.active) {
-      return { error: 'already-active', sessionId: this.sessionId };
-    }
-    this.sessionId = ts.replace(/[:.]/g, '-');
+    if (this.active) return { error: "already-active", sessionId: this.sessionId };
+    this.sessionId = ts.replace(/[:.]/g, "-");
     this.originatingClient = originatingClient;
-    fs.mkdirSync(this.baseDir, { recursive: true });
-    const wsLogPath = path.join(this.baseDir, `session-${this.sessionId}-ws.log`);
-    this.wsStream = fs.createWriteStream(wsLogPath, { flags: 'a' });
+    fs2.mkdirSync(this.baseDir, { recursive: true });
+    this.wsStream = fs2.createWriteStream(path2.join(this.baseDir, `session-${this.sessionId}-ws.log`), { flags: "a" });
     this.active = true;
     console.log(`Debug recording started: ${this.sessionId}`);
     return { sessionId: this.sessionId };
   }
-
   logFrame(direction, data) {
-    if (!this.active || !this.wsStream) return;
-    this.wsStream.write(`${new Date().toISOString()} ${direction} ${data}\n`);
+    if (this.active && this.wsStream) this.wsStream.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${direction} ${data}
+`);
   }
-
   saveDump(payload) {
     if (!this.sessionId) return { sessionId: null, files: [] };
     const files = [];
     const id = this.sessionId;
-
     if (this.wsStream) {
       this.wsStream.end();
       this.wsStream = null;
       files.push(`session-${id}-ws.log`);
     }
-
-    const clientLogPath = path.join(this.baseDir, `session-${id}-client.log`);
-    let logContent = '';
-    for (const entry of (payload.console || [])) {
-      const args = entry.args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
-      logContent += `${entry.ts} [${entry.level.toUpperCase()}] ${args}\n`;
-    }
-    for (const err of (payload.errors || [])) {
-      logContent += `${err.ts} [UNHANDLED] ${err.message}\n${err.stack || ''}\n`;
+    let logContent = "";
+    for (const entry of payload.console || []) {
+      logContent += `${entry.ts} [${entry.level.toUpperCase()}] ${entry.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
     }
+    for (const err of payload.errors || []) logContent += `${err.ts} [UNHANDLED] ${err.message}
+${err.stack || ""}
+`;
     if (logContent) {
-      fs.writeFileSync(clientLogPath, logContent);
+      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-client.log`), logContent);
       files.push(`session-${id}-client.log`);
     }
-
     if (payload.state) {
-      const statePath = path.join(this.baseDir, `session-${id}-state.json`);
-      fs.writeFileSync(statePath, JSON.stringify(payload.state, null, 2));
+      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-state.json`), JSON.stringify(payload.state, null, 2));
       files.push(`session-${id}-state.json`);
     }
-
     if (payload.screenshot) {
-      const ssPath = path.join(this.baseDir, `session-${id}-screenshot.jpg`);
-      fs.writeFileSync(ssPath, Buffer.from(payload.screenshot, 'base64'));
+      fs2.writeFileSync(path2.join(this.baseDir, `session-${id}-screenshot.jpg`), Buffer.from(payload.screenshot, "base64"));
       files.push(`session-${id}-screenshot.jpg`);
     }
-
     const savedId = id;
     this.active = false;
     this.sessionId = null;
     this.originatingClient = null;
-    console.log(`Debug session saved: ${files.join(', ')}`);
+    console.log(`Debug session saved: ${files.join(", ")}`);
     return { sessionId: savedId, files };
   }
-
   handleClientDisconnect(ws) {
     if (this.active && this.originatingClient === ws) {
       console.log(`Debug session ${this.sessionId} auto-closed: client disconnected`);
       if (this.wsStream) {
-        this.wsStream.write(`${new Date().toISOString()} SYSTEM Client disconnected — session auto-closed\n`);
+        this.wsStream.write(`${(/* @__PURE__ */ new Date()).toISOString()} SYSTEM Client disconnected \u2014 session auto-closed
+`);
         this.wsStream.end();
         this.wsStream = null;
       }
@@ -198,965 +147,643 @@ class DebugLogger {
       this.originatingClient = null;
     }
   }
-}
+};
 
-const debugLogger = new DebugLogger(DATA_DIR);
-const HOME = os.homedir();
-const MAX_PREAMBLE_CHARS = 50000;
+// server/gateway.js
+import path4 from "node:path";
+import { WebSocket as WS } from "ws";
 
-// ─── Config.js Parser ────────────────────────────────────────────────────────
-
-function parseConfigField(field) {
-  try {
-    const configPath = path.join(__dirname, 'config.js');
-    const configText = fs.readFileSync(configPath, 'utf8');
-    const match = configText.match(new RegExp(`${field}:\\s*['"]([^'"]+)['"]`));
-    return match ? match[1] : null;
-  } catch { return null; }
+// server/bootstrap/identity.js
+import crypto from "node:crypto";
+import fs3 from "node:fs";
+import path3 from "node:path";
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function derivePublicKeyRaw(publicKeyPem) {
+  const spki = crypto.createPublicKey(publicKeyPem).export({ type: "spki", format: "der" });
+  if (spki.length === ED25519_SPKI_PREFIX.length + 32 && spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+    return spki.subarray(ED25519_SPKI_PREFIX.length);
+  }
+  return spki;
 }
-
-// Load auth token from config.js or env var
-let AUTH_TOKEN = process.env.CLAWCHATS_AUTH_TOKEN || process.env.SHELLCHAT_AUTH_TOKEN || parseConfigField('authToken') || '';
-if (!AUTH_TOKEN) {
-  console.error('WARNING: No auth token configured. Set CLAWCHATS_AUTH_TOKEN or create config.js');
+__name(derivePublicKeyRaw, "derivePublicKeyRaw");
+function fingerprintPublicKey(publicKeyPem) {
+  return crypto.createHash("sha256").update(derivePublicKeyRaw(publicKeyPem)).digest("hex");
 }
-
-// Load gateway WebSocket URL
-// Priority: env var → OpenClaw config (local) → conventional default
-// NOTE: Do NOT use config.js gatewayUrl — that's the browser's external-facing URL.
-// server.js needs the internal/local gateway address.
-function discoverGatewayWsUrl() {
-  if (process.env.GATEWAY_WS_URL) return process.env.GATEWAY_WS_URL;
-  // Read OpenClaw's own config for the local gateway port
-  const candidates = [
-    path.join(os.homedir(), '.openclaw', 'openclaw.json'),
-    '/etc/openclaw/openclaw.json'
-  ];
-  for (const cfgPath of candidates) {
-    try {
-      const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-      const port = raw.gateway?.port || raw.port;
-      const host = raw.gateway?.host || raw.host || 'localhost';
-      if (port) return `ws://${host}:${port}`;
-    } catch {}
-  }
-  return 'ws://localhost:18789';
+__name(fingerprintPublicKey, "fingerprintPublicKey");
+function base64UrlEncode(buf) {
+  return buf.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
 }
-const GATEWAY_WS_URL = discoverGatewayWsUrl();
-
-// ─── Sessions Directory Discovery ────────────────────────────────────────────
-
-function discoverViaCliSync() {
+__name(base64UrlEncode, "base64UrlEncode");
+function loadOrCreateDeviceIdentity(identityPath) {
   try {
-    const output = execSync('openclaw status --json', { encoding: 'utf8', timeout: 5000 });
-    const status = JSON.parse(output);
-    if (status.sessions?.paths?.[0]) {
-      return path.dirname(status.sessions.paths[0]);
+    if (fs3.existsSync(identityPath)) {
+      const parsed = JSON.parse(fs3.readFileSync(identityPath, "utf8"));
+      if (parsed?.version === 1 && parsed.deviceId && parsed.publicKeyPem && parsed.privateKeyPem) return parsed;
     }
-  } catch { /* cli not available or failed */ }
-  return null;
+  } catch {
+  }
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+  const identity = { version: 1, deviceId: fingerprintPublicKey(publicKeyPem), publicKeyPem, privateKeyPem, createdAtMs: Date.now() };
+  fs3.mkdirSync(path3.dirname(identityPath), { recursive: true });
+  fs3.writeFileSync(identityPath, JSON.stringify(identity, null, 2) + "\n", { mode: 384 });
+  return identity;
 }
-
-const OPENCLAW_SESSIONS_DIR = (() => {
-  if (process.env.OPENCLAW_SESSIONS_DIR) {
-    console.log(`Sessions dir: ${process.env.OPENCLAW_SESSIONS_DIR} (source: env)`);
-    return process.env.OPENCLAW_SESSIONS_DIR;
-  }
-  const configDir = parseConfigField('sessionsDir');
-  if (configDir) {
-    console.log(`Sessions dir: ${configDir} (source: config)`);
-    return configDir;
-  }
-  const cliDir = discoverViaCliSync();
-  if (cliDir) {
-    console.log(`Sessions dir: ${cliDir} (source: cli)`);
-    return cliDir;
-  }
-  const fallback = path.join(HOME, '.openclaw', 'agents', 'main', 'sessions');
-  console.log(`Sessions dir: ${fallback} (source: fallback)`);
-  return fallback;
-})();
-
-// ─── Agent Helpers ───────────────────────────────────────────────────────────
-
-function getSessionsDirForAgent(agentId) {
-  if (!agentId || agentId === 'main') return OPENCLAW_SESSIONS_DIR;
-  return path.join(HOME, '.openclaw', 'agents', agentId, 'sessions');
+__name(loadOrCreateDeviceIdentity, "loadOrCreateDeviceIdentity");
+function buildDeviceAuth(identity, { clientId, clientMode, role, scopes, token, nonce }) {
+  const signedAt = Date.now();
+  const payload = ["v2", identity.deviceId, clientId, clientMode, role, scopes.join(","), String(signedAt), token || "", nonce].join("|");
+  const privateKey = crypto.createPrivateKey(identity.privateKeyPem);
+  const signature = base64UrlEncode(crypto.sign(null, Buffer.from(payload, "utf8"), privateKey));
+  const publicKeyB64Url = base64UrlEncode(derivePublicKeyRaw(identity.publicKeyPem));
+  return { id: identity.deviceId, publicKey: publicKeyB64Url, signature, signedAt, nonce };
 }
+__name(buildDeviceAuth, "buildDeviceAuth");
 
-function validateAgent(agentId) {
-  if (!agentId) return 'main';
-  if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) throw new Error('Invalid agent ID');
-  const agentDir = path.join(HOME, '.openclaw', 'agents', agentId);
-  if (!fs.existsSync(agentDir)) throw new Error(`Agent not found: ${agentId}`);
-  return agentId;
+// server/util/helpers.js
+function syncThreadUnreadCount(db, threadId) {
+  const count = db.prepare("SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?").get(threadId).c;
+  db.prepare("UPDATE threads SET unread_count = ? WHERE id = ?").run(count, threadId);
+  return count;
 }
-
-// ─── Workspace Management ───────────────────────────────────────────────────
-
-function ensureDirs() {
-  fs.mkdirSync(DATA_DIR, { recursive: true });
-  fs.mkdirSync(UPLOADS_DIR, { recursive: true });
+__name(syncThreadUnreadCount, "syncThreadUnreadCount");
+function parseSessionKey(sessionKey) {
+  if (!sessionKey) return null;
+  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
+  if (!match) return null;
+  return { agent: match[1], workspace: match[2], threadId: match[3] };
 }
-
-function loadWorkspaces() {
-  try {
-    return JSON.parse(fs.readFileSync(WORKSPACES_FILE, 'utf8'));
-  } catch {
-    const initial = {
-      active: 'default',
-      workspaces: {
-        default: {
-          name: 'default',
-          label: 'Default',
-          createdAt: Date.now()
-        }
-      }
-    };
-    fs.writeFileSync(WORKSPACES_FILE, JSON.stringify(initial, null, 2));
-    return initial;
+__name(parseSessionKey, "parseSessionKey");
+function extractContent(message) {
+  if (!message) return "";
+  if (typeof message.content === "string") return message.content;
+  if (Array.isArray(message.content)) {
+    return message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
   }
+  return "";
 }
-
-function saveWorkspaces(data) {
-  fs.writeFileSync(WORKSPACES_FILE, JSON.stringify(data, null, 2));
-}
-
-let workspacesConfig = null;
-
-function getWorkspaces() {
-  if (!workspacesConfig) workspacesConfig = loadWorkspaces();
-  return workspacesConfig;
+__name(extractContent, "extractContent");
+function isSilentReplyExact(text, token = "NO_REPLY") {
+  if (!text) return false;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
 }
-
-function setWorkspaces(data) {
-  workspacesConfig = data;
-  saveWorkspaces(data);
+__name(isSilentReplyExact, "isSilentReplyExact");
+function isSilentReplyPrefix(text, token = "NO_REPLY") {
+  if (!text) return false;
+  const trimmed = text.trimStart();
+  if (!trimmed) return false;
+  if (trimmed !== trimmed.toUpperCase()) return false;
+  const normalized = trimmed.toUpperCase();
+  if (normalized.length < 2 || /[^A-Z_]/.test(normalized)) return false;
+  const tokenUpper = token.toUpperCase();
+  if (!tokenUpper.startsWith(normalized)) return false;
+  if (normalized.includes("_")) return true;
+  return tokenUpper === "NO_REPLY" && normalized === "NO";
 }
-
-// ─── Database Management ────────────────────────────────────────────────────
-
-const dbCache = new Map(); // name → Database instance
-
-function getDb(workspaceName) {
-  if (dbCache.has(workspaceName)) return dbCache.get(workspaceName);
-  const dbPath = path.join(DATA_DIR, `${workspaceName}.db`);
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.pragma('foreign_keys = ON');
-  migrate(db);
-  dbCache.set(workspaceName, db);
-  return db;
+__name(isSilentReplyPrefix, "isSilentReplyPrefix");
+function stripTrailingSentinel(text, token = "NO_REPLY") {
+  if (!text) return text;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), "").trim();
 }
-
-function getActiveDb() {
-  return _requestDbStore.getStore() || getDb(getWorkspaces().active);
+__name(stripTrailingSentinel, "stripTrailingSentinel");
+function stripFinalTags(text) {
+  return text ? text.replace(/<\s*\/?\s*final\s*>/gi, "") : text;
 }
-
-const _globalDbCache = new Map(); // keyed by resolved dbPath
-function getGlobalDb(dataDir = DATA_DIR) {
-  const dbPath = path.join(dataDir, 'global.db');
-  if (_globalDbCache.has(dbPath)) return _globalDbCache.get(dbPath);
-  fs.mkdirSync(dataDir, { recursive: true });
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS custom_emojis (
-      name TEXT NOT NULL,
-      pack TEXT NOT NULL DEFAULT 'slackmojis',
-      url TEXT NOT NULL,
-      mime_type TEXT,
-      created_at INTEGER DEFAULT (strftime('%s','now')),
-      PRIMARY KEY (name, pack)
-    )
-  `);
-  _globalDbCache.set(dbPath, db);
-  return db;
+__name(stripFinalTags, "stripFinalTags");
+function sanitizeAssistantContent(text) {
+  if (!text) return text;
+  let out = stripFinalTags(text);
+  out = out.replace(/^(?:[ \t]*\r?\n)+/, "");
+  if (out.includes("NO_REPLY")) out = stripTrailingSentinel(out, "NO_REPLY");
+  if (out.includes("HEARTBEAT_OK")) out = stripTrailingSentinel(out, "HEARTBEAT_OK");
+  return out;
 }
-
-function closeDb(workspaceName) {
-  const db = dbCache.get(workspaceName);
-  if (db) {
-    db.close();
-    dbCache.delete(workspaceName);
+__name(sanitizeAssistantContent, "sanitizeAssistantContent");
+function generateActivitySummary(steps) {
+  const toolSteps = steps.filter((s) => s.type === "tool" && s.phase !== "result" && s.phase !== "update");
+  const hasThinking = steps.some((s) => s.type === "thinking" && s.text);
+  const hasNarration = steps.some((s) => s.type === "assistant" && s.text?.trim());
+  if (toolSteps.length === 0 && !hasThinking && !hasNarration) return null;
+  if (toolSteps.length === 0 && hasThinking) return "Reasoned through the problem";
+  if (toolSteps.length === 0 && hasNarration) return "Processed in multiple steps";
+  const counts = {};
+  for (const s of toolSteps) {
+    const name = s.name || "unknown";
+    counts[name] = (counts[name] || 0) + 1;
   }
+  const toolNames = { web_search: "searched the web", web_fetch: "fetched web pages", Read: "read files", read: "read files", Write: "wrote files", write: "wrote files", Edit: "edited files", edit: "edited files", exec: "ran commands", Bash: "ran commands", browser: "browsed the web", memory_search: "searched memory", memory_store: "saved to memory", image: "analyzed images", message: "sent messages", sessions_spawn: "spawned sub-agents", cron: "managed cron jobs", Grep: "searched code", grep: "searched code", Glob: "found files", glob: "found files" };
+  const parts = [];
+  for (const [name, count] of Object.entries(counts)) {
+    const friendly = toolNames[name];
+    parts.push(friendly ? count > 1 ? `${friendly} (${count}\xD7)` : friendly : count > 1 ? `used ${name} (${count}\xD7)` : `used ${name}`);
+  }
+  if (parts.length === 0) return null;
+  if (parts.length === 1) return parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
+  const last = parts.pop();
+  return (parts.join(", ") + " and " + last).replace(/^./, (c) => c.toUpperCase());
 }
-
-function closeAllDbs() {
-  for (const [, db] of dbCache) db.close();
-  dbCache.clear();
-  for (const [, db] of _globalDbCache) db.close();
-  _globalDbCache.clear();
-}
-
-function _createFtsTables(db) {
-  // Each statement must be a separate db.exec() call — SQLite's multi-statement exec
-  // splits on every semicolon including those inside BEGIN...END trigger bodies,
-  // which breaks trigger creation with an "unrecognized token" error.
-  db.exec(`CREATE VIRTUAL TABLE messages_fts USING fts5(
-    content,
-    content=messages,
-    content_rowid=rowid,
-    tokenize='porter unicode61 tokenchars x27'
-  )`);
-  db.exec(`CREATE TRIGGER messages_ai AFTER INSERT ON messages BEGIN
-    INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content);
-  END`);
-  db.exec(`CREATE TRIGGER messages_ad AFTER DELETE ON messages BEGIN
-    INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content);
-  END`);
-  db.exec(`CREATE TRIGGER messages_au AFTER UPDATE ON messages BEGIN
-    INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content);
-    INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content);
-  END`);
-}
-
-function _dropFtsTables(db) {
-  db.exec(`
-    DROP TABLE IF EXISTS messages_fts;
-    DROP TRIGGER IF EXISTS messages_ai;
-    DROP TRIGGER IF EXISTS messages_ad;
-    DROP TRIGGER IF EXISTS messages_au;
-  `);
+__name(generateActivitySummary, "generateActivitySummary");
+function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
+  if (!log._parsed) log._parsed = parseSessionKey(log.sessionKey);
+  const parsed = log._parsed;
+  if (!parsed) return;
+  const db = getDbFn(parsed.workspace);
+  if (!db) return;
+  const cleanSteps = log.steps.map((s) => {
+    const c = { ...s };
+    delete c._sealed;
+    return c;
+  });
+  const summary = generateActivitySummary(log.steps);
+  const now = Date.now();
+  if (!log._messageId) {
+    const thread = db.prepare("SELECT id FROM threads WHERE id = ?").get(parsed.threadId);
+    if (!thread) return;
+    const messageId = `gw-activity-${runId}`;
+    const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
+    try {
+      db.prepare(`INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)`).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
+      log._messageId = messageId;
+      broadcastFn(JSON.stringify({ type: "clawchats", event: "message-saved", threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now }));
+    } catch (err) {
+      console.error(`[activity] Failed to write activity ${messageId}:`, err.message);
+    }
+  } else {
+    const existing = db.prepare("SELECT metadata FROM messages WHERE id = ?").get(log._messageId);
+    const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
+    metadata.activityLog = cleanSteps;
+    metadata.activitySummary = summary;
+    metadata.pending = true;
+    db.prepare("UPDATE messages SET metadata = ? WHERE id = ?").run(JSON.stringify(metadata), log._messageId);
+  }
 }
+__name(writeActivityToDb, "writeActivityToDb");
 
-function migrate(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS threads (
-      id TEXT PRIMARY KEY,
-      session_key TEXT UNIQUE NOT NULL,
-      title TEXT DEFAULT 'New chat',
-      pinned INTEGER DEFAULT 0,
-      pin_order INTEGER DEFAULT 0,
-      model TEXT,
-      last_session_id TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS messages (
-      id TEXT PRIMARY KEY,
-      thread_id TEXT NOT NULL,
-      role TEXT NOT NULL,
-      content TEXT NOT NULL,
-      status TEXT DEFAULT 'sent',
-      metadata TEXT,
-      seq INTEGER,
-      timestamp INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages(thread_id, timestamp);
-    CREATE INDEX IF NOT EXISTS idx_messages_dedup ON messages(thread_id, role, timestamp);
-  `);
-
-  // Migration: add sort_order column if missing
-  try {
-    db.exec('ALTER TABLE threads ADD COLUMN sort_order INTEGER DEFAULT 0');
-  } catch (e) {
-    // Column already exists — ignore
+// server/gateway.js
+var GatewayClient = class {
+  static {
+    __name(this, "GatewayClient");
   }
-
-  // Migration: add unread_count column if missing
-  try {
-    db.exec('ALTER TABLE threads ADD COLUMN unread_count INTEGER DEFAULT 0');
-  } catch (e) {
-    // Column already exists — ignore
+  constructor({ getDb, getWorkspaces, dataDir, debugLogger, gatewayWsUrl, authToken, mediaStash }) {
+    this.getDb = getDb;
+    this.getWorkspaces = getWorkspaces;
+    this.dataDir = dataDir;
+    this.debugLogger = debugLogger;
+    this.gatewayWsUrl = gatewayWsUrl;
+    this.authToken = authToken;
+    this.mediaStash = mediaStash;
+    this.ws = null;
+    this.connected = false;
+    this.reconnectAttempts = 0;
+    this.maxReconnectDelay = 3e4;
+    this.browserClients = /* @__PURE__ */ new Map();
+    this._externalBroadcastTargets = [];
+    this.streamState = /* @__PURE__ */ new Map();
+    this.activityLogs = /* @__PURE__ */ new Map();
+    this._pendingTitleGens = /* @__PURE__ */ new Map();
+    setInterval(() => {
+      const cutoff = Date.now() - 10 * 60 * 1e3;
+      for (const [runId, log] of this.activityLogs) {
+        if (log.startTime < cutoff) {
+          if (log._messageId) {
+            const db = this.getDb(log._parsed?.workspace);
+            if (db) db.prepare(`UPDATE messages SET content = '[Response interrupted]', metadata = json_remove(metadata, '$.pending') WHERE id = ? AND content = ''`).run(log._messageId);
+          }
+          this.activityLogs.delete(runId);
+        }
+      }
+    }, 5 * 60 * 1e3);
+  }
+  connect() {
+    if (this.ws && (this.ws.readyState === WS.CONNECTING || this.ws.readyState === WS.OPEN)) return;
+    console.log(`Connecting to gateway at ${this.gatewayWsUrl}...`);
+    this.ws = new WS(this.gatewayWsUrl);
+    this.ws.on("open", () => {
+      console.log("Gateway WebSocket connected");
+      this.reconnectAttempts = 0;
+    });
+    this.ws.on("message", (data) => this.handleGatewayMessage(data.toString()));
+    this.ws.on("close", () => {
+      console.log("Gateway WebSocket closed");
+      this.connected = false;
+      this.broadcastGatewayStatus(false);
+      this.scheduleReconnect();
+    });
+    this.ws.on("error", (err) => console.error("Gateway WebSocket error:", err.message));
   }
-
-  // Migration: unread_messages table for per-message read tracking
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS unread_messages (
-      thread_id TEXT NOT NULL,
-      message_id TEXT NOT NULL,
-      created_at INTEGER NOT NULL,
-      PRIMARY KEY (thread_id, message_id),
-      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
-    )
-  `);
-  db.exec('CREATE INDEX IF NOT EXISTS idx_unread_thread ON unread_messages(thread_id)');
-
-  // FTS5 table — CREATE VIRTUAL TABLE doesn't support IF NOT EXISTS in all versions,
-  // so check existence first, then verify integrity and auto-repair if corrupted.
-  const hasFts = db.prepare(
-    "SELECT name FROM sqlite_master WHERE type='table' AND name='messages_fts'"
-  ).get();
-  if (!hasFts) {
+  handleGatewayMessage(data) {
+    this.debugLogger.logFrame("GW\u2192SRV", data);
+    let msg;
     try {
-      _createFtsTables(db);
-      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
-    } catch (ftsCreateErr) {
-      console.error('[DB] messages_fts creation failed, search disabled:', ftsCreateErr.message);
+      msg = JSON.parse(data);
+    } catch {
+      console.error("Invalid JSON from gateway:", data);
+      return;
+    }
+    if (msg.type === "event" && msg.event === "connect.challenge") {
+      const identity = loadOrCreateDeviceIdentity(path4.join(this.dataDir, "device-identity.json"));
+      const device = buildDeviceAuth(identity, { clientId: "gateway-client", clientMode: "backend", role: "operator", scopes: ["operator.read", "operator.write", "operator.admin"], token: this.authToken, nonce: msg.payload?.nonce || "" });
+      this.ws.send(JSON.stringify({ type: "req", id: "gw-connect-1", method: "connect", params: { minProtocol: 3, maxProtocol: 3, client: { id: "gateway-client", version: "0.1.0", platform: "node", mode: "backend" }, role: "operator", scopes: ["operator.read", "operator.write", "operator.admin"], device, auth: { token: this.authToken }, caps: ["tool-events"] } }));
+      return;
+    }
+    if (msg.type === "res" && msg.payload?.type === "hello-ok") {
+      console.log("Gateway handshake complete");
+      this.connected = true;
+      this.broadcastGatewayStatus(true);
+    }
+    if (msg.type === "event" && msg.event === "chat" && msg.payload) {
+      this.handleChatEvent(msg.payload, data);
+    } else {
+      this.broadcastToBrowsers(data);
     }
-  } else {
-    // Migration: rebuild FTS table if tokenizer is outdated (missing tokenchars for apostrophe support).
-    // Old tokenizer split "there's" into ["there", "s"] causing contraction searches to return 0 results.
-    const ftsSchema = db.prepare(
-      "SELECT sql FROM sqlite_master WHERE type='table' AND name='messages_fts'"
-    ).get();
-    const needsTokenizerUpgrade = ftsSchema && !ftsSchema.sql.includes('tokenchars');
-    if (needsTokenizerUpgrade) {
-      console.log('[DB] messages_fts tokenizer upgrade required (apostrophe support) — rebuilding index...');
-      try {
-        _dropFtsTables(db);
-        _createFtsTables(db);
-        db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
-        console.log('[DB] messages_fts tokenizer upgrade complete — apostrophes in contractions now searchable');
-      } catch (upgradeErr) {
-        console.error('[DB] messages_fts tokenizer upgrade failed, dropping for graceful degradation:', upgradeErr.message);
-        _dropFtsTables(db);
+    if (msg.type === "event" && msg.event === "agent" && msg.payload) this.handleAgentEvent(msg.payload);
+  }
+  handleChatEvent(params, rawData) {
+    const { sessionKey, state, message, seq } = params;
+    if (state === "delta") {
+      const parsed = parseSessionKey(sessionKey);
+      if (parsed) {
+        const existing = this.streamState.get(sessionKey) || { buffer: "", threadId: parsed.threadId, state: "streaming", held: [] };
+        existing.buffer += extractContent(message);
+        if (isSilentReplyPrefix(existing.buffer, "NO_REPLY") || isSilentReplyPrefix(existing.buffer, "HEARTBEAT_OK")) {
+          existing.held = existing.held || [];
+          existing.held.push(rawData);
+          this.streamState.set(sessionKey, existing);
+          return;
+        }
+        if (existing.held?.length > 0) {
+          for (const h of existing.held) this.broadcastToBrowsers(h);
+          existing.held = [];
+        }
+        this.streamState.set(sessionKey, existing);
       }
-    } else {
-      // Integrity check: corruption causes all message writes to 500.
-      // Attempt rebuild first; if that fails, drop entirely for graceful degradation
-      // (messages still save, search returns empty until next restart recreates the table).
-      try {
-        db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('integrity-check')").run();
-      } catch (err) {
-        console.warn('[DB] messages_fts integrity check failed, attempting rebuild:', err.message);
-        try {
-          db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
-          console.log('[DB] messages_fts rebuilt successfully — search index restored');
-        } catch (rebuildErr) {
-          console.error('[DB] messages_fts rebuild failed, dropping FTS for graceful degradation:', rebuildErr.message);
-          _dropFtsTables(db);
-          // On the next gateway restart the table will be recreated fresh via the !hasFts path
+      this.broadcastToBrowsers(rawData);
+      return;
+    }
+    const streamEntry = this.streamState.get(sessionKey);
+    if (state === "final" || state === "aborted" || state === "error") this.streamState.delete(sessionKey);
+    if (sessionKey?.includes("__clawchats_title_")) {
+      if (state === "final") {
+        const content = extractContent(message);
+        if (content && this.handleTitleResponse(sessionKey, content)) return;
+      } else if (state === "error" || state === "aborted") {
+        for (const key of this._pendingTitleGens.keys()) {
+          if (sessionKey === key || sessionKey.includes(key)) {
+            this._pendingTitleGens.delete(key);
+            break;
+          }
         }
+        return;
       }
     }
+    if (state === "final") {
+      const rawContent = extractContent(message);
+      if (isSilentReplyExact(rawContent, "NO_REPLY") || isSilentReplyExact(rawContent, "HEARTBEAT_OK")) return;
+      if (streamEntry?.held?.length > 0) for (const h of streamEntry.held) this.broadcastToBrowsers(h);
+      this.broadcastToBrowsers(rawData);
+      this.saveAssistantMessage(sessionKey, message, seq);
+      return;
+    }
+    if (state === "aborted" || state === "error") this.broadcastToBrowsers(rawData);
+    if (state === "error") this.saveErrorMarker(sessionKey, message);
   }
-}
-
-// ─── HTTP Helpers ───────────────────────────────────────────────────────────
+  saveAssistantMessage(sessionKey, message, seq) {
+    const parsed = parseSessionKey(sessionKey);
+    if (!parsed) return;
+    const ws = this.getWorkspaces();
+    if (!ws.workspaces[parsed.workspace]) {
+      console.log(`Ignoring response for deleted workspace: ${parsed.workspace}`);
+      return;
+    }
+    const db = this.getDb(parsed.workspace);
+    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(parsed.threadId)) {
+      console.log(`Ignoring response for deleted thread: ${parsed.threadId}`);
+      return;
+    }
+    let content = sanitizeAssistantContent(extractContent(message));
+    if (!content?.trim()) {
+      console.log(`Skipping empty assistant response for thread ${parsed.threadId}`);
+      return;
+    }
+    const pendingPaths = this.mediaStash?.get(sessionKey) ?? [];
+    this.mediaStash?.delete(sessionKey);
+    const IMAGE_EXTS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg", "ico", "avif", "tiff"]);
+    const AUDIO_EXTS = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "m4a", "flac", "aac", "opus", "wma"]);
+    const imagePaths = [], pendingAttachments = [];
+    for (const p of pendingPaths) {
+      const ext = (p.split(".").pop() || "").toLowerCase();
+      if (IMAGE_EXTS.has(ext)) imagePaths.push(p);
+      else pendingAttachments.push({ path: p, name: p.split("/").pop(), type: AUDIO_EXTS.has(ext) ? "audio" : "file" });
+    }
+    if (imagePaths.length > 0) content = content.trimEnd() + "\n\n" + imagePaths.map((p) => `![image](${p})`).join("\n");
+    if (pendingPaths.length > 0) console.log(`[clawchats] media-attach: ${imagePaths.length} image(s), ${pendingAttachments.length} attachment(s) for ${sessionKey}`);
+    const now = Date.now();
+    const pendingMsg = db.prepare(`SELECT id, metadata FROM messages WHERE thread_id = ? AND role = 'assistant' AND json_extract(metadata, '$.pending') = 1 ORDER BY timestamp DESC LIMIT 1`).get(parsed.threadId);
+    let messageId;
+    if (pendingMsg) {
+      const metadata = pendingMsg.metadata ? JSON.parse(pendingMsg.metadata) : {};
+      delete metadata.pending;
+      if (metadata.activityLog) {
+        const idx = metadata.activityLog.findLastIndex((s) => s.type === "assistant");
+        if (idx >= 0) metadata.activityLog.splice(idx, 1);
+        metadata.activitySummary = generateActivitySummary(metadata.activityLog);
+      }
+      if (pendingAttachments.length > 0) metadata.attachments = [...metadata.attachments || [], ...pendingAttachments];
+      db.prepare("UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?").run(content, JSON.stringify(metadata), now, pendingMsg.id);
+      messageId = pendingMsg.id;
+    } else {
+      messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
+      const newMeta = pendingAttachments.length > 0 ? JSON.stringify({ attachments: pendingAttachments }) : null;
+      db.prepare(`INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', ?, 'sent', ?, ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, metadata = COALESCE(excluded.metadata, metadata), timestamp = excluded.timestamp`).run(messageId, parsed.threadId, content, newMeta, now, now);
+    }
+    try {
+      db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(now, parsed.threadId);
+      db.prepare("INSERT OR IGNORE INTO unread_messages (thread_id, message_id, created_at) VALUES (?, ?, ?)").run(parsed.threadId, messageId, now);
+      syncThreadUnreadCount(db, parsed.threadId);
+      const threadInfo = db.prepare("SELECT title FROM threads WHERE id = ?").get(parsed.threadId);
+      const unreadCount = db.prepare("SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?").get(parsed.threadId).c;
+      const preview = content.length > 120 ? content.substring(0, 120) + "..." : content;
+      this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "message-saved", threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now, title: threadInfo?.title, preview, unreadCount, updatedContent: imagePaths.length > 0 ? content : void 0, updatedAttachments: pendingAttachments.length > 0 ? pendingAttachments : void 0 }));
+      this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "unread-update", workspace: parsed.workspace, threadId: parsed.threadId, messageId, action: "new", unreadCount, workspaceUnreadTotal: db.prepare("SELECT COALESCE(SUM(unread_count), 0) as total FROM threads").get().total, title: threadInfo?.title, preview, timestamp: now }));
+      console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (${pendingMsg ? "merged into pending" : "seq: " + seq})`);
+      const msgCount = db.prepare("SELECT COUNT(*) as c FROM messages WHERE thread_id = ?").get(parsed.threadId).c;
+      if (msgCount === 2 || threadInfo?.title === "New chat") this.generateThreadTitle(db, parsed.threadId, parsed.workspace, true);
+    } catch (e) {
+      console.error("Failed to save assistant message:", e.message);
+    }
+  }
+  saveErrorMarker(sessionKey, message) {
+    const parsed = parseSessionKey(sessionKey);
+    if (!parsed) return;
+    const ws = this.getWorkspaces();
+    if (!ws.workspaces[parsed.workspace]) return;
+    const db = this.getDb(parsed.workspace);
+    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(parsed.threadId)) return;
+    const now = Date.now();
+    try {
+      db.prepare("INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(`gw-error-${parsed.threadId}-${now}`, parsed.threadId, "system", `[error] ${message?.error || message?.content || "Unknown error"}`, "sent", '{"transient":true}', now, now);
+    } catch (e) {
+      console.error("Failed to save error marker:", e.message);
+    }
+  }
+  generateThreadTitle(db, threadId, workspace, skipHeuristic = false) {
+    if (!db.prepare("SELECT title FROM threads WHERE id = ?").get(threadId)) return;
+    const titleKey = `__clawchats_title_${threadId}`;
+    if (this._pendingTitleGens.has(titleKey)) return;
+    const firstUserMsg = db.prepare("SELECT content FROM messages WHERE thread_id = ? AND role = 'user' ORDER BY created_at ASC LIMIT 1").get(threadId);
+    if (!firstUserMsg?.content) return;
+    if (!skipHeuristic) {
+      const heuristic = firstUserMsg.content.replace(/\n.*/s, "").slice(0, 40).trim() + (firstUserMsg.content.length > 40 ? "..." : "");
+      db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(heuristic, threadId);
+      this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "thread-title-updated", threadId, workspace, title: heuristic }));
+    }
+    const messages = db.prepare("SELECT role, content FROM messages WHERE thread_id = ? ORDER BY created_at ASC LIMIT 6").all(threadId);
+    if (messages.length < 2) return;
+    const conversation = messages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content.length > 300 ? m.content.slice(0, 300) + "..." : m.content}`).join("\n\n");
+    const reqId = `title-${threadId}-${Date.now()}`;
+    this._pendingTitleGens.set(titleKey, { threadId, workspace, reqId });
+    setTimeout(() => {
+      if (this._pendingTitleGens.has(titleKey)) {
+        this._pendingTitleGens.delete(titleKey);
+        console.log(`Title gen timeout for ${threadId}`);
+      }
+    }, 3e4);
+    this.sendToGateway(JSON.stringify({ type: "req", id: reqId, method: "chat.send", params: { sessionKey: titleKey, message: `Based on this conversation, generate a concise 3-5 word title. Return ONLY the title text, no quotes, no explanation:
 
-function parseBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on('data', c => chunks.push(c));
-    req.on('end', () => {
-      const raw = Buffer.concat(chunks).toString();
-      if (!raw) return resolve({});
-      try { resolve(JSON.parse(raw)); }
-      catch { reject(new Error('Invalid JSON')); }
-    });
-    req.on('error', reject);
-  });
-}
+${conversation}
 
-function send(res, status, data) {
-  const body = JSON.stringify(data);
-  res.writeHead(status, {
-    'Content-Type': 'application/json',
-    'Access-Control-Allow-Origin': '*',
-    'Access-Control-Allow-Methods': 'GET, POST, PATCH, DELETE, OPTIONS',
-    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-  });
-  res.end(body);
-}
-
-function sendError(res, status, message) {
-  send(res, status, { error: message });
-}
-
-function setCors(res) {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-}
-
-function uuid() {
-  return crypto.randomUUID();
-}
-
-// ─── Route matching ─────────────────────────────────────────────────────────
-
-function matchRoute(method, url, pattern) {
-  // pattern like "GET /api/threads/:id/messages/:messageId"
-  const [pMethod, pPath] = pattern.split(' ');
-  if (method !== pMethod) return null;
-  const pParts = pPath.split('/').filter(Boolean);
-  const uParts = url.split('/').filter(Boolean);
-  if (pParts.length !== uParts.length) return null;
-  const params = {};
-  for (let i = 0; i < pParts.length; i++) {
-    if (pParts[i].startsWith(':')) {
-      params[pParts[i].slice(1)] = decodeURIComponent(uParts[i]);
-    } else if (pParts[i] !== uParts[i]) {
-      return null;
-    }
+Title:`, deliver: false, idempotencyKey: reqId } }));
   }
-  return params;
-}
-
-// ─── Auth Middleware ─────────────────────────────────────────────────────────
-
-function checkAuth(req, res) {
-  if (!AUTH_TOKEN) return true; // no token configured = open
-  const auth = req.headers.authorization;
-  if (!auth || !auth.startsWith('Bearer ')) {
-    sendError(res, 401, 'Missing or invalid Authorization header');
-    return false;
-  }
-  const token = auth.slice(7);
-  if (token !== AUTH_TOKEN) {
-    sendError(res, 401, 'Invalid auth token');
-    return false;
-  }
-  return true;
-}
-
-// ─── Multipart Parser (minimal, for file uploads) ───────────────────────────
-
-function parseMultipart(req) {
-  return new Promise((resolve, reject) => {
-    const contentType = req.headers['content-type'] || '';
-    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
-    if (!boundaryMatch) return reject(new Error('No boundary in content-type'));
-    const boundary = boundaryMatch[1] || boundaryMatch[2];
-    const chunks = [];
-    req.on('data', c => chunks.push(c));
-    req.on('end', () => {
-      const buf = Buffer.concat(chunks);
-      const files = [];
-      const delimiter = Buffer.from(`--${boundary}`);
-      const end = Buffer.from(`--${boundary}--`);
-
-      let pos = 0;
-      while (pos < buf.length) {
-        const start = buf.indexOf(delimiter, pos);
-        if (start === -1) break;
-        const nextStart = buf.indexOf(delimiter, start + delimiter.length);
-        if (nextStart === -1) break;
-
-        const part = buf.subarray(start + delimiter.length, nextStart);
-        const headerEnd = part.indexOf('\r\n\r\n');
-        if (headerEnd === -1) { pos = nextStart; continue; }
-
-        const headerStr = part.subarray(0, headerEnd).toString();
-        let body = part.subarray(headerEnd + 4);
-        // Trim trailing \r\n
-        if (body.length >= 2 && body[body.length - 2] === 0x0d && body[body.length - 1] === 0x0a) {
-          body = body.subarray(0, body.length - 2);
-        }
-
-        const filenameMatch = headerStr.match(/filename="([^"]+)"/);
-        const ctMatch = headerStr.match(/Content-Type:\s*(\S+)/i);
-        if (filenameMatch) {
-          files.push({
-            filename: filenameMatch[1],
-            mimeType: ctMatch ? ctMatch[1] : 'application/octet-stream',
-            data: body,
-          });
-        }
-        pos = nextStart;
-      }
-      resolve(files);
-    });
-    req.on('error', reject);
-  });
-}
-
-// ─── Context Fill Helper ────────────────────────────────────────────────────
-
-function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
-  let summary = null;
-  let method = 'raw';
-
-  // Try to read old JSONL transcript
-  if (lastSessionId) {
-    const agentMatch = (sessionKey || '').match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const jsonlPath = path.join(sessionsDir, `${lastSessionId}.jsonl`);
-    try {
-      const content = fs.readFileSync(jsonlPath, 'utf8');
-      const lines = content.split('\n').filter(Boolean);
-      // Find last compaction entry
-      for (let i = lines.length - 1; i >= 0; i--) {
-        try {
-          const entry = JSON.parse(lines[i]);
-          if (entry.type === 'compaction' && entry.summary) {
-            summary = entry.summary;
-            method = 'compaction';
-            break;
-          }
-        } catch { /* skip malformed lines */ }
+  handleTitleResponse(sessionKey, content) {
+    let matchKey = null, pending = null;
+    for (const [key, val] of this._pendingTitleGens) {
+      if (sessionKey === key || sessionKey.includes(key)) {
+        matchKey = key;
+        pending = val;
+        break;
       }
-    } catch { /* file not found, fall back to raw */ }
+    }
+    if (!pending) return false;
+    this._pendingTitleGens.delete(matchKey);
+    let title = content.trim().replace(/^["']|["']$/g, "").replace(/^Title:\s*/i, "").replace(/\n.*/s, "").trim();
+    if (title.length > 50) title = title.substring(0, 47) + "...";
+    if (!title || title.length >= 100) return true;
+    const db = this.getDb(pending.workspace);
+    db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(title, pending.threadId);
+    this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "thread-title-updated", threadId: pending.threadId, workspace: pending.workspace, title }));
+    console.log(`AI title generated for ${pending.threadId}: "${title}"`);
+    return true;
   }
-
-  // Build preamble
-  let preamble = '';
-
-  if (method === 'compaction' && summary) {
-    preamble += '[CONTEXT RECOVERY — This thread\'s agent session was reset. Below is a summary of the previous conversation followed by recent messages to restore context.]\n\n';
-    preamble += '[CONVERSATION SUMMARY]\n';
-    preamble += summary + '\n\n';
-
-    // Last 10 messages from SQLite
-    const msgs = db.prepare(
-      'SELECT role, content, timestamp FROM messages WHERE thread_id = ? ORDER BY timestamp DESC LIMIT 10'
-    ).all(threadId).reverse();
-
-    if (msgs.length) {
-      preamble += '[RECENT MESSAGES]\n';
-      for (const m of msgs) {
-        const d = new Date(m.timestamp);
-        const ts = d.toISOString().replace('T', ' ').slice(0, 16);
-        const role = m.role.charAt(0).toUpperCase() + m.role.slice(1);
-        preamble += `${role} (${ts}): ${m.content}\n`;
+  handleAgentEvent(payload) {
+    const { runId, stream, data, sessionKey } = payload;
+    if (!runId) return;
+    if (!this.activityLogs.has(runId)) this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
+    const log = this.activityLogs.get(runId);
+    if (stream === "assistant") {
+      const text = data?.text || "";
+      if (text) {
+        let seg = log._currentAssistantSegment;
+        if (!seg || seg._sealed) {
+          seg = { type: "assistant", timestamp: Date.now(), text, _sealed: false };
+          log._currentAssistantSegment = seg;
+          log.steps.push(seg);
+        } else seg.text = text;
       }
+      return;
     }
-  } else {
-    preamble += '[CONTEXT RECOVERY — This thread\'s agent session was reset. Below are recent messages from the previous conversation to restore context.]\n\n';
-
-    // Last 25 messages from SQLite
-    const msgs = db.prepare(
-      'SELECT role, content, timestamp FROM messages WHERE thread_id = ? ORDER BY timestamp DESC LIMIT 25'
-    ).all(threadId).reverse();
-
-    if (msgs.length) {
-      preamble += '[PREVIOUS MESSAGES]\n';
-      for (const m of msgs) {
-        const d = new Date(m.timestamp);
-        const ts = d.toISOString().replace('T', ' ').slice(0, 16);
-        const role = m.role.charAt(0).toUpperCase() + m.role.slice(1);
-        preamble += `${role} (${ts}): ${m.content}\n`;
+    if (stream === "thinking") {
+      let step = log.steps.find((s) => s.type === "thinking");
+      if (step) step.text = data?.text || "";
+      else log.steps.push({ type: "thinking", timestamp: Date.now(), text: data?.text || "" });
+      writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
+      const now = Date.now();
+      if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
+        log._lastThinkingBroadcast = now;
+        this._broadcastActivityUpdate(runId, log);
       }
     }
+    if (stream === "tool") {
+      if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
+      const argsMeta = data?.args ? data.args.command || data.args.path || data.args.query || data.args.url || Object.values(data.args).find((v) => typeof v === "string") || "" : "";
+      const step = { type: "tool", timestamp: Date.now(), name: data?.name || "unknown", phase: data?.phase || "start", toolCallId: data?.toolCallId, meta: data?.meta || (argsMeta ? String(argsMeta) : void 0), isError: data?.isError || false };
+      if (data?.phase === "result") {
+        const existing = log.steps.findLast((s) => s.toolCallId === data.toolCallId && (s.phase === "start" || s.phase === "running"));
+        if (existing) {
+          existing.phase = "done";
+          existing.resultMeta = data?.meta;
+          existing.isError = data?.isError || false;
+          existing.durationMs = Date.now() - existing.timestamp;
+        } else {
+          step.phase = "done";
+          log.steps.push(step);
+        }
+      } else if (data?.phase === "update") {
+        const existing = log.steps.findLast((s) => s.toolCallId === data.toolCallId);
+        if (existing) {
+          if (data?.meta) existing.resultMeta = data.meta;
+          if (data?.isError) existing.isError = true;
+          existing.phase = "running";
+        }
+      } else log.steps.push(step);
+      writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
+      this._broadcastActivityUpdate(runId, log);
+    }
+    if (stream === "lifecycle" && (data?.phase === "end" || data?.phase === "error")) {
+      if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
+      const idx = log.steps.findLastIndex((s) => s.type === "assistant");
+      if (idx >= 0) log.steps.splice(idx, 1);
+      writeActivityToDb(this.getDb, this.broadcastToBrowsers.bind(this), runId, log);
+      this.activityLogs.delete(runId);
+    }
+  }
+  _broadcastActivityUpdate(runId, log) {
+    if (!log._parsed || !log._messageId) return;
+    const cleanSteps = log.steps.map((s) => {
+      const c = { ...s };
+      delete c._sealed;
+      return c;
+    });
+    this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "activity-updated", workspace: log._parsed.workspace, threadId: log._parsed.threadId, messageId: log._messageId, activityLog: cleanSteps, activitySummary: generateActivitySummary(log.steps) }));
   }
-
-  // Enforce token budget
-  if (preamble.length > MAX_PREAMBLE_CHARS) {
-    preamble = preamble.slice(preamble.length - MAX_PREAMBLE_CHARS);
-  }
-
-  return { preamble, method };
-}
-
-// ─── Gateway Session Cleanup ─────────────────────────────────────────────────
-
-function cleanGatewaySession(sessionKey) {
-  try {
-    const agentMatch = (sessionKey || '').match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const sessionsPath = path.join(sessionsDir, 'sessions.json');
-    const raw = fs.readFileSync(sessionsPath, 'utf8');
-    const store = JSON.parse(raw);
-    const entry = store[sessionKey];
-    if (!entry) return null;
-
-    // Delete .jsonl transcript
-    if (entry.sessionId) {
-      const jsonlPath = path.join(sessionsDir, `${entry.sessionId}.jsonl`);
-      try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
+  broadcastToBrowsers(data) {
+    this.debugLogger.logFrame("SRV\u2192BR", data);
+    for (const client of this.browserClients.keys()) {
+      if (client.readyState === WS.OPEN) client.send(data);
     }
-
-    // Remove entry from store and write back
-    const sessionId = entry.sessionId || null;
-    delete store[sessionKey];
-    fs.writeFileSync(sessionsPath, JSON.stringify(store, null, 2));
-    return sessionId;
-  } catch (err) {
-    console.warn(`cleanGatewaySession(${sessionKey}):`, err.message);
-    return null;
-  }
-}
-
-function cleanGatewaySessionsByPrefix(prefix) {
-  try {
-    const agentMatch = (prefix || '').match(/^agent:([^:]+):/);
-    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
-    const sessionsPath = path.join(sessionsDir, 'sessions.json');
-    const raw = fs.readFileSync(sessionsPath, 'utf8');
-    const store = JSON.parse(raw);
-    let cleaned = 0;
-
-    for (const key of Object.keys(store)) {
-      if (!key.startsWith(prefix)) continue;
-      const entry = store[key];
-      if (entry?.sessionId) {
-        const jsonlPath = path.join(sessionsDir, `${entry.sessionId}.jsonl`);
-        try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
+    for (const fn of this._externalBroadcastTargets) {
+      try {
+        fn(data);
+      } catch {
       }
-      delete store[key];
-      cleaned++;
     }
-
-    if (cleaned > 0) {
-      fs.writeFileSync(sessionsPath, JSON.stringify(store, null, 2));
-    }
-    return cleaned;
-  } catch (err) {
-    console.warn(`cleanGatewaySessionsByPrefix(${prefix}):`, err.message);
-    return 0;
-  }
-}
-
-// ─── File Serving (restricted to ~/.openclaw/media/) ────────────────────────
-
-const ALLOWED_FILE_DIRS = [
-  HOME,
-  '/tmp',
-];
-
-function handleServeFile(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, 'Missing path parameter');
-
-  // Resolve to prevent traversal attacks
-  // Relative paths (./filename) resolve against the workspace directory
-  const resolved = (filePath.startsWith('./') || filePath.startsWith('../'))
-    ? path.resolve(MEMORY_CONFIG.workspaceDir, filePath)
-    : path.resolve(filePath);
-
-  // Security: only serve files from allowed directories
-  const allowed = ALLOWED_FILE_DIRS.some(dir => resolved.startsWith(dir + '/') || resolved === dir);
-  if (!allowed) {
-    return sendError(res, 403, 'Access denied: path not in allowed directories');
   }
-
-  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
-    return sendError(res, 404, 'File not found');
+  broadcastGatewayStatus(connected) {
+    this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "gateway-status", connected }));
   }
-
-  const ext = path.extname(resolved).toLowerCase();
-  const mimeTypes = {
-    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
-    '.pdf': 'application/pdf', '.txt': 'text/plain', '.json': 'application/json',
-    '.md': 'text/markdown', '.csv': 'text/csv', '.xml': 'text/xml',
-    '.html': 'text/html', '.css': 'text/css', '.js': 'text/javascript',
-    '.py': 'text/x-python', '.sh': 'text/x-shellscript',
-    '.yaml': 'text/yaml', '.yml': 'text/yaml', '.toml': 'text/toml',
-    '.zip': 'application/zip', '.gz': 'application/gzip', '.tar': 'application/x-tar',
-    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.ogg': 'audio/ogg',
-    '.mp4': 'video/mp4', '.webm': 'video/webm',
-  };
-  const contentType = mimeTypes[ext] || 'application/octet-stream';
-
-  const stat = fs.statSync(resolved);
-  res.writeHead(200, {
-    'Content-Type': contentType,
-    'Content-Length': stat.size,
-    'Cache-Control': 'public, max-age=86400',
-    'Access-Control-Allow-Origin': '*',
-  });
-  fs.createReadStream(resolved).pipe(res);
-}
-
-// ─── Workspace File Browser ─────────────────────────────────────────────────
-
-const WORKSPACE_ROOT = HOME;
-
-function handleWorkspaceList(req, res, query) {
-  const reqPath = query.path || '~/.openclaw/workspace';
-  const depth = parseInt(query.depth || '2', 10);
-  const showHidden = query.hidden === '1' || query.hidden === 'true';
-
-  // Resolve ~ to HOME
-  const resolved = path.resolve(reqPath.replace(/^~/, HOME));
-
-  // Security: only allow listing under home directory
-  if (!resolved.startsWith(HOME)) {
-    return sendError(res, 403, 'Access denied');
+  sendToGateway(data) {
+    this.debugLogger.logFrame("SRV\u2192GW", data);
+    if (this.ws?.readyState === WS.OPEN) this.ws.send(data);
+    else console.error("Cannot send to gateway: not connected");
   }
-
-  if (!fs.existsSync(resolved)) {
-    return sendError(res, 404, 'Path not found');
+  scheduleReconnect() {
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+    this.reconnectAttempts++;
+    console.log(`Reconnecting to gateway in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+    setTimeout(() => this.connect(), delay);
   }
-
-  const files = [];
-
-  function walk(dir, currentDepth) {
-    if (currentDepth > depth) return;
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        // Skip hidden files unless showHidden (always show .openclaw)
-        if (entry.name.startsWith('.') && entry.name !== '.openclaw' && !showHidden) continue;
-        if (entry.name === 'node_modules') continue;
-
-        const fullPath = path.join(dir, entry.name);
-        const isDir = entry.isDirectory();
-        files.push({
-          path: fullPath + (isDir ? '/' : ''),
-          type: isDir ? 'dir' : 'file',
-          name: entry.name,
-          size: isDir ? 0 : (() => { try { return fs.statSync(fullPath).size; } catch { return 0; } })(),
-        });
-        if (isDir) walk(fullPath, currentDepth + 1);
+  addBrowserClient(ws) {
+    this.browserClients.set(ws, { activeWorkspace: null, activeThreadId: null });
+    if (ws.readyState === WS.OPEN) {
+      ws.send(JSON.stringify({ type: "clawchats", event: "gateway-status", connected: this.connected }));
+      const streams = [];
+      for (const [sessionKey, state] of this.streamState.entries()) {
+        if (state.state === "streaming" && !(state.held?.length > 0)) streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
       }
-    } catch { /* permission denied, etc. */ }
-  }
-
-  // Add root entry
-  files.unshift({ path: resolved + '/', type: 'dir', name: path.basename(resolved), size: 0 });
-  walk(resolved, 1);
-
-  send(res, 200, { files, cwd: resolved });
-}
-
-function handleWorkspaceFileRead(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, 'Missing path parameter');
-
-  const resolved = path.resolve(filePath.replace(/^~/, HOME));
-
-  // Security: only allow reading under home directory
-  if (!resolved.startsWith(HOME)) {
-    return sendError(res, 403, 'Access denied');
-  }
-
-  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
-    return sendError(res, 404, 'File not found');
-  }
-
-  const stat = fs.statSync(resolved);
-  const ext = path.extname(resolved).toLowerCase().slice(1);
-
-  // MIME type map — binary types get served as binary, rest as text
-  const mimeMap = {
-    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
-    gif: 'image/gif', webp: 'image/webp', svg: 'image/svg+xml',
-    bmp: 'image/bmp', ico: 'image/x-icon',
-    pdf: 'application/pdf',
-    mp3: 'audio/mpeg', mp4: 'video/mp4', wav: 'audio/wav',
-    ogg: 'audio/ogg', webm: 'video/webm',
-  };
-  const mime = mimeMap[ext];
-  const isBinary = !!mime;
-
-  if (isBinary) {
-    if (stat.size > 20 * 1024 * 1024) return sendError(res, 413, 'File too large (max 20MB)');
-    const content = fs.readFileSync(resolved);
-    res.writeHead(200, { 'Content-Type': mime, 'Cache-Control': 'private, max-age=60' });
-    res.end(content);
-  } else {
-    if (stat.size > 1024 * 1024) return sendError(res, 413, 'File too large (max 1MB)');
-    const content = fs.readFileSync(resolved, 'utf8');
-    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
-    res.end(content);
-  }
-}
-
-async function handleWorkspaceFileWrite(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, 'Missing path parameter');
-
-  const resolved = path.resolve(filePath.replace(/^~/, HOME));
-
-  // Security: only allow writing under workspace
-  if (!resolved.startsWith(WORKSPACE_ROOT)) {
-    return sendError(res, 403, 'Can only write to workspace directory');
-  }
-
-  // Read body as text
-  const chunks = [];
-  for await (const chunk of req) chunks.push(chunk);
-  const content = Buffer.concat(chunks).toString('utf8');
-
-  // Ensure parent directory exists
-  const dir = path.dirname(resolved);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-
-  fs.writeFileSync(resolved, content, 'utf8');
-  send(res, 200, { ok: true });
-}
-
-function handleWorkspaceFileDelete(req, res, query) {
-  const filePath = query.path;
-  if (!filePath) return sendError(res, 400, 'Missing path parameter');
-
-  const resolved = path.resolve(filePath.replace(/^~/, HOME));
-
-  // Security: only allow paths under home directory
-  if (!resolved.startsWith(HOME)) {
-    return sendError(res, 403, 'Access denied');
-  }
-
-  if (!fs.existsSync(resolved)) {
-    return sendError(res, 404, 'Path not found');
-  }
-
-  try {
-    const stat = fs.statSync(resolved);
-    if (stat.isDirectory()) {
-      fs.rmSync(resolved, { recursive: true, force: true });
-      send(res, 200, { ok: true, type: 'dir' });
-    } else {
-      fs.unlinkSync(resolved);
-      send(res, 200, { ok: true, type: 'file' });
+      if (streams.length > 0) ws.send(JSON.stringify({ type: "clawchats", event: "stream-sync", streams }));
     }
-  } catch (err) {
-    sendError(res, 500, 'Delete failed: ' + err.message);
-  }
-}
-
-async function handleWorkspaceUpload(req, res, query) {
-  const targetDir = query.path;
-  if (!targetDir) return sendError(res, 400, 'Missing path parameter');
-
-  const resolved = path.resolve(targetDir.replace(/^~/, HOME));
-
-  // Security: only allow uploading under home directory
-  if (!resolved.startsWith(HOME)) {
-    return sendError(res, 403, 'Access denied');
   }
-
-  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
-    return sendError(res, 404, 'Target directory not found');
-  }
-
-  // Parse multipart form data manually (no dependency needed for simple case)
-  const contentType = req.headers['content-type'] || '';
-  if (!contentType.includes('multipart/form-data')) {
-    return sendError(res, 400, 'Expected multipart/form-data');
+  removeBrowserClient(ws) {
+    this.browserClients.delete(ws);
   }
-
-  const boundary = contentType.split('boundary=')[1];
-  if (!boundary) return sendError(res, 400, 'Missing boundary');
-
-  const chunks = [];
-  for await (const chunk of req) chunks.push(chunk);
-  const body = Buffer.concat(chunks);
-
-  // Parse multipart parts
-  const boundaryBuf = Buffer.from('--' + boundary);
-  const uploaded = [];
-  let start = 0;
-
-  while (true) {
-    const idx = body.indexOf(boundaryBuf, start);
-    if (idx === -1) break;
-
-    if (start > 0) {
-      // Extract the part between previous boundary and this one
-      const partData = body.slice(start, idx - 2); // -2 for \r\n before boundary
-      const headerEnd = partData.indexOf('\r\n\r\n');
-      if (headerEnd !== -1) {
-        const headerStr = partData.slice(0, headerEnd).toString('utf8');
-        const fileContent = partData.slice(headerEnd + 4);
-
-        const filenameMatch = headerStr.match(/filename="([^"]+)"/);
-        if (filenameMatch && fileContent.length > 0) {
-          const filename = path.basename(filenameMatch[1]); // sanitize
-          const filePath = path.join(resolved, filename);
-
-          // Don't overwrite — add suffix if exists
-          let finalPath = filePath;
-          let counter = 1;
-          while (fs.existsSync(finalPath)) {
-            const ext = path.extname(filename);
-            const base = path.basename(filename, ext);
-            finalPath = path.join(resolved, `${base} (${counter})${ext}`);
-            counter++;
-          }
-
-          fs.writeFileSync(finalPath, fileContent);
-          uploaded.push({ name: path.basename(finalPath), size: fileContent.length });
-        }
+  setActiveThread(ws, workspace, threadId) {
+    const client = ws ? this.browserClients.get(ws) : null;
+    if (client) {
+      client.activeWorkspace = workspace;
+      client.activeThreadId = threadId;
+    }
+    if (!workspace || !threadId) return;
+    try {
+      const wsData = this.getWorkspaces();
+      if (!wsData.workspaces[workspace]) return;
+      const db = this.getDb(workspace);
+      if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(threadId)) return;
+      const deleted = db.prepare("DELETE FROM unread_messages WHERE thread_id = ?").run(threadId);
+      if (deleted.changes > 0) {
+        syncThreadUnreadCount(db, threadId);
+        this.broadcastToBrowsers(JSON.stringify({ type: "clawchats", event: "unread-update", workspace, threadId, action: "clear", unreadCount: 0, workspaceUnreadTotal: db.prepare("SELECT COALESCE(SUM(unread_count), 0) as total FROM threads").get().total, timestamp: Date.now() }));
       }
+    } catch (e) {
+      console.error("Failed to auto-clear unreads on active-thread:", e.message);
     }
-
-    start = idx + boundaryBuf.length + 2; // +2 for \r\n after boundary
   }
+  addBroadcastTarget(fn) {
+    this._externalBroadcastTargets.push(fn);
+  }
+  removeBroadcastTarget(fn) {
+    this._externalBroadcastTargets = this._externalBroadcastTargets.filter((f) => f !== fn);
+  }
+};
 
-  send(res, 200, { ok: true, uploaded });
-}
-
-// ─── Memory (configurable backend) ──────────────────────────────────────────
-
+// server/providers/memory.js
+import fs4 from "node:fs";
+import path5 from "node:path";
+import os2 from "node:os";
 function discoverMemoryConfig() {
-  // Priority: env vars → openclaw.json → defaults
-  const defaults = { provider: 'qdrant', host: 'localhost', port: 6333, collection: null };
-
-  // Try reading openclaw.json
+  const defaults = { provider: "qdrant", host: "localhost", port: 6333, collection: null };
   let oc = null;
-  const candidates = [
-    path.join(os.homedir(), '.openclaw', 'openclaw.json'),
-    '/etc/openclaw/openclaw.json'
-  ];
-  for (const cfgPath of candidates) {
+  for (const cfgPath of [path5.join(os2.homedir(), ".openclaw", "openclaw.json"), "/etc/openclaw/openclaw.json"]) {
     try {
-      oc = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+      oc = JSON.parse(fs4.readFileSync(cfgPath, "utf8"));
       break;
-    } catch {}
+    } catch {
+    }
   }
-
   let cfg = { ...defaults };
-
   if (oc) {
-    const memSlot = oc.plugins?.slots?.memory;
-    const vs = memSlot ? oc.plugins?.entries?.[memSlot]?.config?.oss?.vectorStore : null;
+    const vs = oc.plugins?.slots?.memory ? oc.plugins?.entries?.[oc.plugins.slots.memory]?.config?.oss?.vectorStore : null;
     if (vs) {
       if (vs.provider) cfg.provider = vs.provider;
       if (vs.config?.host) cfg.host = vs.config.host;
       if (vs.config?.port) cfg.port = vs.config.port;
       if (vs.config?.collectionName) cfg.collection = vs.config.collectionName;
-      // Postgres-specific fields
       if (vs.config?.user) cfg.pgUser = vs.config.user;
       if (vs.config?.password) cfg.pgPassword = vs.config.password;
       if (vs.config?.dbname) cfg.pgDbName = vs.config.dbname;
     }
-
-    // Derive workspace dir from openclaw.json
     const wsDir = oc.agents?.defaults?.workspace;
     if (wsDir) cfg.workspaceDir = wsDir;
   }
-
-  // Env var overrides (MEMORY_* take priority, then Qdrant-specific fallbacks)
   if (process.env.MEMORY_PROVIDER) cfg.provider = process.env.MEMORY_PROVIDER;
   if (process.env.MEMORY_HOST || process.env.QDRANT_HOST) cfg.host = process.env.MEMORY_HOST || process.env.QDRANT_HOST;
   if (process.env.MEMORY_PORT || process.env.QDRANT_PORT) cfg.port = parseInt(process.env.MEMORY_PORT || process.env.QDRANT_PORT, 10);
   if (process.env.MEMORY_COLLECTION || process.env.QDRANT_COLLECTION) cfg.collection = process.env.MEMORY_COLLECTION || process.env.QDRANT_COLLECTION;
   if (process.env.MEMORY_PG_URL) cfg.pgUrl = process.env.MEMORY_PG_URL;
-  // QDRANT_URL (e.g. "http://myhost:6333") — parse host and port from it
   if (process.env.QDRANT_URL && !process.env.MEMORY_HOST) {
     try {
       const u = new URL(process.env.QDRANT_URL);
       cfg.host = u.hostname;
       if (u.port) cfg.port = parseInt(u.port, 10);
-    } catch {}
+    } catch {
+    }
   }
-
-  if (!cfg.workspaceDir) {
-    cfg.workspaceDir = path.join(os.homedir(), '.openclaw', 'workspace');
-  }
-
+  if (!cfg.workspaceDir) cfg.workspaceDir = path5.join(os2.homedir(), ".openclaw", "workspace");
   return cfg;
 }
-
-const MEMORY_CONFIG = discoverMemoryConfig();
-
-// Auto-detect Qdrant collection if not explicitly configured
+__name(discoverMemoryConfig, "discoverMemoryConfig");
 async function autoDetectQdrantCollection(config) {
   if (config.collection) return config.collection;
-  const baseUrl = `http://${config.host}:${config.port}`;
   try {
-    const r = await fetch(`${baseUrl}/collections`, { signal: AbortSignal.timeout(3000) });
+    const r = await fetch(`http://${config.host}:${config.port}/collections`, { signal: AbortSignal.timeout(3e3) });
     const data = await r.json();
-    const collections = (data.result?.collections || []).map(c => c.name);
-    const found = collections.find(name => !name.includes('migration'));
+    const found = (data.result?.collections || []).map((c) => c.name).find((n) => !n.includes("migration"));
     if (found) {
       console.log(`Memory: auto-detected Qdrant collection "${found}"`);
       return found;
     }
-  } catch {}
+  } catch {
+  }
   console.log('Memory: Qdrant unreachable or no collections, falling back to "memories"');
-  return 'memories';
+  return "memories";
 }
-
-// ─── Memory Providers ─────────────────────────────────────────────────────────
-
+__name(autoDetectQdrantCollection, "autoDetectQdrantCollection");
 function createQdrantProvider(config) {
   const baseUrl = `http://${config.host}:${config.port}`;
-  let collection = config.collection; // may be null until init()
-
+  let collection = config.collection;
   return {
-    name: 'qdrant',
+    name: "qdrant",
     config,
     async init() {
       collection = await autoDetectQdrantCollection(config);
@@ -1165,17 +792,9 @@ function createQdrantProvider(config) {
     async list(limit, offset) {
       const body = { limit, with_payload: true, with_vector: false };
       if (offset) body.offset = offset;
-      const r = await fetch(`${baseUrl}/collections/${collection}/points/scroll`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-      });
+      const r = await fetch(`${baseUrl}/collections/${collection}/points/scroll`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
       const data = await r.json();
-      const points = data.result?.points || [];
-      return {
-        memories: points.map(p => ({ id: p.id, ...p.payload })),
-        next_offset: data.result?.next_page_offset || null,
-      };
+      return { memories: (data.result?.points || []).map((p) => ({ id: p.id, ...p.payload })), next_offset: data.result?.next_page_offset || null };
     },
     async search(query) {
       const q = query.toLowerCase();
@@ -1184,116 +803,73 @@ function createQdrantProvider(config) {
       do {
         const body = { limit: 100, with_payload: true, with_vector: false };
         if (offset) body.offset = offset;
-        const r = await fetch(`${baseUrl}/collections/${collection}/points/scroll`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(body),
-        });
+        const r = await fetch(`${baseUrl}/collections/${collection}/points/scroll`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
         const data = await r.json();
-        const points = data.result?.points || [];
-        for (const p of points) {
-          if ((p.payload?.data || '').toLowerCase().includes(q)) {
-            matches.push({ id: p.id, ...p.payload });
-          }
+        for (const p of data.result?.points || []) {
+          if ((p.payload?.data || "").toLowerCase().includes(q)) matches.push({ id: p.id, ...p.payload });
         }
         offset = data.result?.next_page_offset || null;
       } while (offset);
       return { memories: matches, next_offset: null };
     },
     async update(id, newData) {
-      const r = await fetch(`${baseUrl}/collections/${collection}/points/payload`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ points: [id], payload: { data: newData } }),
-      });
+      const r = await fetch(`${baseUrl}/collections/${collection}/points/payload`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ points: [id], payload: { data: newData } }) });
       const data = await r.json();
       if (data.status?.error) throw new Error(data.status.error);
       return data.result;
     },
     async delete(id) {
-      const r = await fetch(`${baseUrl}/collections/${collection}/points/delete`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ points: [id] }),
-      });
-      const data = await r.json();
-      return data.result;
+      const r = await fetch(`${baseUrl}/collections/${collection}/points/delete`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ points: [id] }) });
+      return (await r.json()).result;
     },
     async status() {
       try {
-        const r = await fetch(`${baseUrl}/collections/${collection}`, { signal: AbortSignal.timeout(3000) });
+        const r = await fetch(`${baseUrl}/collections/${collection}`, { signal: AbortSignal.timeout(3e3) });
         const data = await r.json();
         return { reachable: true, pointsCount: data.result?.points_count ?? null };
       } catch {
         return { reachable: false };
       }
-    },
+    }
   };
 }
-
+__name(createQdrantProvider, "createQdrantProvider");
 function createPgProvider(config) {
-  // Lazy-load pg — no crash if not installed and user runs Qdrant
-  // NOTE: Postgres schema based on mem0 SDK pgvector patterns; needs verification against a real setup.
   let _pool = null;
-  const table = config.collection || 'memories';
-
+  const table = config.collection || "memories";
   async function getPool() {
     if (_pool) return _pool;
     let pg;
     try {
-      pg = await import('pg');
+      pg = await import("pg");
     } catch {
-      throw new Error('pg package not installed. Run: npm install pg');
+      throw new Error("pg package not installed. Run: npm install pg");
     }
     const Pool = pg.default?.Pool || pg.Pool;
-    if (config.pgUrl) {
-      _pool = new Pool({ connectionString: config.pgUrl });
-    } else {
-      _pool = new Pool({
-        host: config.host,
-        port: config.port || 5432,
-        user: config.pgUser || 'mem0',
-        password: config.pgPassword || '',
-        database: config.pgDbName || 'mem0',
-      });
-    }
+    _pool = config.pgUrl ? new Pool({ connectionString: config.pgUrl }) : new Pool({ host: config.host, port: config.port || 5432, user: config.pgUser || "mem0", password: config.pgPassword || "", database: config.pgDbName || "mem0" });
     return _pool;
   }
-
+  __name(getPool, "getPool");
   return {
-    name: 'postgres',
+    name: "postgres",
     config,
-    async init() { /* pool created lazily on first query */ },
+    async init() {
+    },
     async list(limit, offset) {
       const pool = await getPool();
-      const offsetVal = offset ? parseInt(offset, 10) : 0;
-      const { rows } = await pool.query(
-        `SELECT id, payload FROM ${table} ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
-        [limit, offsetVal]
-      );
-      return {
-        memories: rows.map(r => ({ id: r.id, ...(typeof r.payload === 'string' ? JSON.parse(r.payload) : r.payload) })),
-        next_offset: rows.length === limit ? offsetVal + limit : null,
-      };
+      const off = offset ? parseInt(offset, 10) : 0;
+      const { rows } = await pool.query(`SELECT id, payload FROM ${table} ORDER BY created_at DESC LIMIT $1 OFFSET $2`, [limit, off]);
+      return { memories: rows.map((r) => ({ id: r.id, ...typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload })), next_offset: rows.length === limit ? off + limit : null };
     },
     async search(query) {
       const pool = await getPool();
-      const { rows } = await pool.query(
-        `SELECT id, payload FROM ${table} WHERE payload->>'data' ILIKE $1 LIMIT 100`,
-        [`%${query}%`]
-      );
-      return {
-        memories: rows.map(r => ({ id: r.id, ...(typeof r.payload === 'string' ? JSON.parse(r.payload) : r.payload) })),
-        next_offset: null,
-      };
+      const { rows } = await pool.query(`SELECT id, payload FROM ${table} WHERE payload->>'data' ILIKE $1 LIMIT 100`, [`%${query}%`]);
+      return { memories: rows.map((r) => ({ id: r.id, ...typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload })), next_offset: null };
     },
     async update(id, newData) {
       const pool = await getPool();
-      const { rowCount } = await pool.query(
-        `UPDATE ${table} SET payload = jsonb_set(payload, '{data}', $1::jsonb) WHERE id = $2`,
-        [JSON.stringify(newData), id]
-      );
-      if (rowCount === 0) throw new Error('Memory not found');
+      const { rowCount } = await pool.query(`UPDATE ${table} SET payload = jsonb_set(payload, '{data}', $1::jsonb) WHERE id = $2`, [JSON.stringify(newData), id]);
+      if (rowCount === 0) throw new Error("Memory not found");
       return { updated: true };
     },
     async delete(id) {
@@ -1309,77 +885,141 @@ function createPgProvider(config) {
       } catch (err) {
         return { reachable: false, error: err.message };
       }
-    },
+    }
   };
 }
-
+__name(createPgProvider, "createPgProvider");
 function createMemoryProvider(config) {
-  if (config.provider === 'postgres' || config.provider === 'pgvector')
-    return createPgProvider(config);
+  if (config.provider === "postgres" || config.provider === "pgvector") return createPgProvider(config);
   return createQdrantProvider(config);
 }
+__name(createMemoryProvider, "createMemoryProvider");
 
-async function handleTranscribe(req, res) {
-  try {
-    const chunks = [];
-    for await (const chunk of req) chunks.push(chunk);
-    const audioBuffer = Buffer.concat(chunks);
-
-    if (audioBuffer.length === 0) return send(res, 400, { error: 'No audio data' });
-    if (audioBuffer.length > 25 * 1024 * 1024) return send(res, 400, { error: 'Audio too large (max 25MB)' });
-
-    // Read OpenAI API key from OpenClaw config
-    let apiKey;
-    try {
-      const ocConfig = JSON.parse(fs.readFileSync(
-        path.join(os.homedir(), '.openclaw', 'openclaw.json'), 'utf8'));
-      apiKey = ocConfig?.skills?.entries?.['openai-whisper-api']?.apiKey;
-    } catch {}
-    if (!apiKey) apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) return send(res, 500, { error: 'No OpenAI API key configured' });
-
-    const contentType = req.headers['content-type'] || 'audio/webm';
-    const ext = contentType.includes('wav') ? 'wav'
-      : contentType.includes('mp4') || contentType.includes('m4a') ? 'm4a'
-      : contentType.includes('ogg') ? 'ogg' : 'webm';
-
-    const boundary = '----WhisperBoundary' + Date.now();
-    const parts = [
-      `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="audio.${ext}"\r\nContent-Type: ${contentType}\r\n\r\n`,
-      audioBuffer,
-      `\r\n--${boundary}\r\nContent-Disposition: form-data; name="model"\r\n\r\nwhisper-1\r\n`,
-      `--${boundary}\r\nContent-Disposition: form-data; name="response_format"\r\n\r\njson\r\n`,
-      `--${boundary}--\r\n`
-    ];
-    const body = Buffer.concat(parts.map(p => typeof p === 'string' ? Buffer.from(p) : p));
+// server/controllers/workspaces.js
+import fs6 from "node:fs";
+import path7 from "node:path";
 
-    const resp = await fetch('https://api.openai.com/v1/audio/transcriptions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': `multipart/form-data; boundary=${boundary}`,
-      },
-      body
+// server/util/http.js
+import crypto2 from "node:crypto";
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw) return resolve({});
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
     });
-
-    if (!resp.ok) {
-      const errText = await resp.text();
-      console.error('Whisper API error:', resp.status, errText);
-      return send(res, 502, { error: `Whisper API error: ${resp.status}` });
+    req.on("error", reject);
+  });
+}
+__name(parseBody, "parseBody");
+function send(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization"
+  });
+  res.end(body);
+}
+__name(send, "send");
+function sendError(res, status, message) {
+  send(res, status, { error: message });
+}
+__name(sendError, "sendError");
+function setCors(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+}
+__name(setCors, "setCors");
+function uuid() {
+  return crypto2.randomUUID();
+}
+__name(uuid, "uuid");
+function matchRoute(method, url, pattern) {
+  const [pMethod, pPath] = pattern.split(" ");
+  if (method !== pMethod) return null;
+  const pParts = pPath.split("/").filter(Boolean);
+  const uParts = url.split("/").filter(Boolean);
+  if (pParts.length !== uParts.length) return null;
+  const params = {};
+  for (let i = 0; i < pParts.length; i++) {
+    if (pParts[i].startsWith(":")) {
+      params[pParts[i].slice(1)] = decodeURIComponent(uParts[i]);
+    } else if (pParts[i] !== uParts[i]) {
+      return null;
     }
+  }
+  return params;
+}
+__name(matchRoute, "matchRoute");
 
-    const result = await resp.json();
-    return send(res, 200, { text: result.text || '' });
+// server/gateway-cleanup.js
+import fs5 from "node:fs";
+import path6 from "node:path";
+function cleanGatewaySession(sessionKey) {
+  try {
+    const agentMatch = (sessionKey || "").match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    const sessionsPath = path6.join(sessionsDir, "sessions.json");
+    const store = JSON.parse(fs5.readFileSync(sessionsPath, "utf8"));
+    const entry = store[sessionKey];
+    if (!entry) return null;
+    if (entry.sessionId) {
+      try {
+        fs5.unlinkSync(path6.join(sessionsDir, `${entry.sessionId}.jsonl`));
+      } catch {
+      }
+    }
+    const sessionId = entry.sessionId || null;
+    delete store[sessionKey];
+    fs5.writeFileSync(sessionsPath, JSON.stringify(store, null, 2));
+    return sessionId;
   } catch (err) {
-    console.error('Transcribe error:', err);
-    return send(res, 500, { error: err.message });
+    console.warn(`cleanGatewaySession(${sessionKey}):`, err.message);
+    return null;
   }
 }
+__name(cleanGatewaySession, "cleanGatewaySession");
+function cleanGatewaySessionsByPrefix(prefix) {
+  try {
+    const agentMatch = (prefix || "").match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    const sessionsPath = path6.join(sessionsDir, "sessions.json");
+    const store = JSON.parse(fs5.readFileSync(sessionsPath, "utf8"));
+    let cleaned = 0;
+    for (const key of Object.keys(store)) {
+      if (!key.startsWith(prefix)) continue;
+      if (store[key]?.sessionId) {
+        try {
+          fs5.unlinkSync(path6.join(sessionsDir, `${store[key].sessionId}.jsonl`));
+        } catch {
+        }
+      }
+      delete store[key];
+      cleaned++;
+    }
+    if (cleaned > 0) fs5.writeFileSync(sessionsPath, JSON.stringify(store, null, 2));
+    return cleaned;
+  } catch (err) {
+    console.warn(`cleanGatewaySessionsByPrefix(${prefix}):`, err.message);
+    return 0;
+  }
+}
+__name(cleanGatewaySessionsByPrefix, "cleanGatewaySessionsByPrefix");
 
-
-// ─── Controllers ─────────────────────────────────────────────────────────────
-
-class WorkspaceController {
+// server/controllers/workspaces.js
+var WorkspaceController = class {
+  static {
+    __name(this, "WorkspaceController");
+  }
   constructor({ getDb, closeDb, getWorkspaces, setWorkspaces, dataDir, broadcast }) {
     this.getDb = getDb;
     this.closeDb = closeDb;
@@ -1388,47 +1028,52 @@ class WorkspaceController {
     this.dataDir = dataDir;
     this.broadcast = broadcast;
   }
-
   getAll(req, res) {
     const ws = this.getWorkspaces();
     const sorted = Object.values(ws.workspaces).sort((a, b) => (a.order ?? 999) - (b.order ?? 999));
     for (const workspace of sorted) {
       try {
-        const db = this.getDb(workspace.name);
-        workspace.unread_count = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
-      } catch { workspace.unread_count = 0; }
+        workspace.unread_count = this.getDb(workspace.name).prepare("SELECT COALESCE(SUM(unread_count), 0) as total FROM threads").get().total;
+      } catch {
+        workspace.unread_count = 0;
+      }
     }
     send(res, 200, { active: ws.active, workspaces: sorted });
   }
-
   async create(req, res) {
     const body = await parseBody(req);
     const { name, label } = body;
-    if (!name || !/^[a-z0-9-]{1,32}$/.test(name)) return sendError(res, 400, 'Name must be [a-z0-9-], 1-32 chars');
+    if (!name || !/^[a-z0-9-]{1,32}$/.test(name)) return sendError(res, 400, "Name must be [a-z0-9-], 1-32 chars");
     const ws = this.getWorkspaces();
-    if (ws.workspaces[name]) return sendError(res, 409, 'Workspace already exists');
-    let agent = 'main';
-    try { agent = validateAgent(body.agent || 'main'); } catch { agent = 'main'; }
-    const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
-    ws.workspaces[name] = workspace;
+    if (ws.workspaces[name]) return sendError(res, 409, "Workspace already exists");
+    let agent = "main";
+    try {
+      agent = validateAgent(body.agent || "main");
+    } catch {
+      agent = "main";
+    }
+    ws.workspaces[name] = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
     this.setWorkspaces(ws);
     this.getDb(name);
-    send(res, 201, { workspace });
+    send(res, 201, { workspace: ws.workspaces[name] });
   }
-
   async update(req, res, params) {
     const body = await parseBody(req);
     const ws = this.getWorkspaces();
-    if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
-    if (body.label !== undefined) ws.workspaces[params.name].label = body.label;
-    if (body.color !== undefined) ws.workspaces[params.name].color = body.color;
-    if (body.icon !== undefined) ws.workspaces[params.name].icon = body.icon;
-    if (body.lastThread !== undefined) ws.workspaces[params.name].lastThread = body.lastThread;
+    if (!ws.workspaces[params.name]) return sendError(res, 404, "Workspace not found");
+    if (body.label !== void 0) ws.workspaces[params.name].label = body.label;
+    if (body.color !== void 0) ws.workspaces[params.name].color = body.color;
+    if (body.icon !== void 0) ws.workspaces[params.name].icon = body.icon;
+    if (body.lastThread !== void 0) ws.workspaces[params.name].lastThread = body.lastThread;
     let migratedThreads = 0;
-    if (body.agent !== undefined) {
+    if (body.agent !== void 0) {
       let newAgent;
-      try { newAgent = validateAgent(body.agent); } catch (e) { return sendError(res, 400, e.message); }
-      const oldAgent = ws.workspaces[params.name].agent || 'main';
+      try {
+        newAgent = validateAgent(body.agent);
+      } catch (e) {
+        return sendError(res, 400, e.message);
+      }
+      const oldAgent = ws.workspaces[params.name].agent || "main";
       if (newAgent !== oldAgent) {
         const db = this.getDb(params.name);
         const threads = db.prepare(`SELECT id, session_key FROM threads WHERE session_key LIKE ?`).all(`agent:${oldAgent}:${params.name}:chat:%`);
@@ -1436,23 +1081,25 @@ class WorkspaceController {
         for (const t of threads) cleanGatewaySession(t.session_key);
         ws.workspaces[params.name].agent = newAgent;
         migratedThreads = threads.length;
-        this.broadcast(JSON.stringify({ type: 'clawchats', event: 'workspace-agent-changed', workspace: params.name, agent: newAgent }));
+        this.broadcast(JSON.stringify({ type: "clawchats", event: "workspace-agent-changed", workspace: params.name, agent: newAgent }));
       }
     }
     this.setWorkspaces(ws);
     send(res, 200, { workspace: ws.workspaces[params.name], migratedThreads });
   }
-
   delete(req, res, params) {
     const ws = this.getWorkspaces();
-    if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
-    if (Object.keys(ws.workspaces).length <= 1) return sendError(res, 400, 'Cannot delete the only workspace');
+    if (!ws.workspaces[params.name]) return sendError(res, 404, "Workspace not found");
+    if (Object.keys(ws.workspaces).length <= 1) return sendError(res, 400, "Cannot delete the only workspace");
     this.closeDb(params.name);
-    const dbPath = path.join(this.dataDir, `${params.name}.db`);
-    try { fs.unlinkSync(dbPath); } catch { /* ok */ }
-    try { fs.unlinkSync(dbPath + '-wal'); } catch { /* ok */ }
-    try { fs.unlinkSync(dbPath + '-shm'); } catch { /* ok */ }
-    const wsAgent = ws.workspaces[params.name]?.agent || 'main';
+    const dbPath = path7.join(this.dataDir, `${params.name}.db`);
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        fs6.unlinkSync(dbPath + suffix);
+      } catch {
+      }
+    }
+    const wsAgent = ws.workspaces[params.name]?.agent || "main";
     const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgent}:${params.name}:chat:`);
     if (cleaned > 0) console.log(`Cleaned ${cleaned} gateway sessions for workspace: ${params.name}`);
     delete ws.workspaces[params.name];
@@ -1460,1423 +1107,1286 @@ class WorkspaceController {
     this.setWorkspaces(ws);
     send(res, 200, { ok: true });
   }
-
   async reorder(req, res) {
     const body = await parseBody(req);
-    const { order } = body;
-    if (!Array.isArray(order)) return sendError(res, 400, 'order must be an array of workspace names');
+    if (!Array.isArray(body.order)) return sendError(res, 400, "order must be an array of workspace names");
     const ws = this.getWorkspaces();
-    order.forEach((name, i) => { if (ws.workspaces[name]) ws.workspaces[name].order = i; });
+    body.order.forEach((name, i) => {
+      if (ws.workspaces[name]) ws.workspaces[name].order = i;
+    });
     this.setWorkspaces(ws);
     send(res, 200, { ok: true, workspaces: Object.values(ws.workspaces) });
   }
-
   activate(req, res, params) {
     const ws = this.getWorkspaces();
-    if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
+    if (!ws.workspaces[params.name]) return sendError(res, 404, "Workspace not found");
     ws.active = params.name;
     this.setWorkspaces(ws);
     this.getDb(params.name);
     send(res, 200, { ok: true, workspace: ws.workspaces[params.name] });
   }
-}
+};
 
-class ThreadController {
+// server/controllers/threads.js
+import fs7 from "node:fs";
+import path8 from "node:path";
+var ThreadController = class {
+  static {
+    __name(this, "ThreadController");
+  }
   constructor({ getActiveDb, getWorkspaces, uploadsDir, broadcast }) {
     this.getActiveDb = getActiveDb;
     this.getWorkspaces = getWorkspaces;
     this.uploadsDir = uploadsDir;
     this.broadcast = broadcast;
   }
-
   getAll(req, res, params, query) {
     const db = this.getActiveDb();
-    const page = parseInt(query.page || '1', 10);
-    const limit = Math.min(parseInt(query.limit || '50', 10), 200);
+    const page = parseInt(query.page || "1", 10);
+    const limit = Math.min(parseInt(query.limit || "50", 10), 200);
     const offset = (page - 1) * limit;
-    const search = query.search || '';
+    const search = query.search || "";
     let threads, total;
     if (search) {
       try {
-        const matchingIds = db.prepare(`SELECT DISTINCT m.thread_id FROM messages m JOIN messages_fts ON messages_fts.rowid = m.rowid WHERE messages_fts MATCH ?`).all(search).map(r => r.thread_id);
-        if (matchingIds.length === 0) return send(res, 200, { threads: [], total: 0, page });
-        const ph = matchingIds.map(() => '?').join(',');
+        const matchingIds = db.prepare(`SELECT DISTINCT m.thread_id FROM messages m JOIN messages_fts ON messages_fts.rowid = m.rowid WHERE messages_fts MATCH ?`).all(search).map((r) => r.thread_id);
+        if (!matchingIds.length) return send(res, 200, { threads: [], total: 0, page });
+        const ph = matchingIds.map(() => "?").join(",");
         total = db.prepare(`SELECT COUNT(*) as c FROM threads WHERE id IN (${ph})`).get(...matchingIds).c;
         threads = db.prepare(`SELECT * FROM threads WHERE id IN (${ph}) ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?`).all(...matchingIds, limit, offset);
-      } catch { return send(res, 200, { threads: [], total: 0, page }); }
+      } catch {
+        return send(res, 200, { threads: [], total: 0, page });
+      }
     } else {
-      total = db.prepare('SELECT COUNT(*) as c FROM threads').get().c;
-      threads = db.prepare('SELECT * FROM threads ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?').all(limit, offset);
+      total = db.prepare("SELECT COUNT(*) as c FROM threads").get().c;
+      threads = db.prepare("SELECT * FROM threads ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?").all(limit, offset);
     }
     send(res, 200, { threads, total, page });
   }
-
   getUnread(req, res) {
     const db = this.getActiveDb();
     const threads = db.prepare(`SELECT t.id, t.title, t.unread_count, m.content as lastMessage FROM threads t LEFT JOIN messages m ON m.thread_id = t.id WHERE t.unread_count > 0 AND m.timestamp = (SELECT MAX(timestamp) FROM messages WHERE thread_id = t.id) ORDER BY t.updated_at DESC`).all();
-    for (const thread of threads) {
-      thread.unreadMessageIds = db.prepare('SELECT message_id FROM unread_messages WHERE thread_id = ?').all(thread.id).map(r => r.message_id);
-    }
+    for (const t of threads) t.unreadMessageIds = db.prepare("SELECT message_id FROM unread_messages WHERE thread_id = ?").all(t.id).map((r) => r.message_id);
     send(res, 200, { threads });
   }
-
   async markRead(req, res, params) {
-    const body = await parseBody(req);
+    const { messageIds } = await parseBody(req);
+    if (!Array.isArray(messageIds) || !messageIds.length) return send(res, 400, { error: "messageIds array required" });
     const db = this.getActiveDb();
-    const { messageIds } = body;
-    if (!Array.isArray(messageIds) || messageIds.length === 0) return send(res, 400, { error: 'messageIds array required' });
-    const ph = messageIds.map(() => '?').join(',');
+    const ph = messageIds.map(() => "?").join(",");
     db.prepare(`DELETE FROM unread_messages WHERE thread_id = ? AND message_id IN (${ph})`).run(params.id, ...messageIds);
     const remaining = syncThreadUnreadCount(db, params.id);
-    const workspace = this.getWorkspaces().active;
-    this.broadcast(JSON.stringify({ type: 'clawchats', event: 'unread-update', workspace, threadId: params.id, action: 'read', messageIds, unreadCount: remaining, timestamp: Date.now() }));
+    this.broadcast(JSON.stringify({ type: "clawchats", event: "unread-update", workspace: this.getWorkspaces().active, threadId: params.id, action: "read", messageIds, unreadCount: remaining, timestamp: Date.now() }));
     send(res, 200, { unread_count: remaining });
   }
-
   async create(req, res) {
     const body = await parseBody(req);
     const db = this.getActiveDb();
     const ws = this.getWorkspaces();
     const id = body.id || uuid();
     const now = Date.now();
-    const agent = ws.workspaces[ws.active]?.agent || 'main';
-    const sessionKey = `agent:${agent}:${ws.active}:chat:${id}`;
+    const agent = ws.workspaces[ws.active]?.agent || "main";
     try {
-      db.prepare('INSERT INTO threads (id, session_key, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)').run(id, sessionKey, 'New chat', now, now);
+      db.prepare("INSERT INTO threads (id, session_key, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(id, `agent:${agent}:${ws.active}:chat:${id}`, "New chat", now, now);
     } catch (e) {
-      if (e.message.includes('UNIQUE constraint')) return sendError(res, 409, 'Thread already exists');
+      if (e.message.includes("UNIQUE constraint")) return sendError(res, 409, "Thread already exists");
       throw e;
     }
-    send(res, 201, { thread: db.prepare('SELECT * FROM threads WHERE id = ?').get(id) });
+    send(res, 201, { thread: db.prepare("SELECT * FROM threads WHERE id = ?").get(id) });
   }
-
   get(req, res, params) {
-    const thread = this.getActiveDb().prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
+    const thread = this.getActiveDb().prepare("SELECT * FROM threads WHERE id = ?").get(params.id);
+    if (!thread) return sendError(res, 404, "Thread not found");
     send(res, 200, { thread });
   }
-
   async update(req, res, params) {
     const body = await parseBody(req);
     const db = this.getActiveDb();
-    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
+    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
     const fields = [], values = [];
-    for (const [col, val] of [['title', body.title], ['model', body.model], ['last_session_id', body.last_session_id], ['unread_count', body.unread_count]]) {
-      if (val !== undefined) { fields.push(`${col} = ?`); values.push(val); }
+    for (const [col, val] of [["title", body.title], ["model", body.model], ["last_session_id", body.last_session_id], ["unread_count", body.unread_count]]) {
+      if (val !== void 0) {
+        fields.push(`${col} = ?`);
+        values.push(val);
+      }
+    }
+    if (body.pinned !== void 0) {
+      fields.push("pinned = ?");
+      values.push(body.pinned ? 1 : 0);
     }
-    if (body.pinned !== undefined) { fields.push('pinned = ?'); values.push(body.pinned ? 1 : 0); }
-    if (body.pin_order !== undefined) { fields.push('pin_order = ?'); values.push(body.pin_order); }
-    if (body.sort_order !== undefined) { fields.push('sort_order = ?'); values.push(body.sort_order); }
-    if (fields.length > 0) {
-      fields.push('updated_at = ?'); values.push(Date.now(), params.id);
-      db.prepare(`UPDATE threads SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+    if (body.pin_order !== void 0) {
+      fields.push("pin_order = ?");
+      values.push(body.pin_order);
     }
-    send(res, 200, { thread: db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id) });
+    if (body.sort_order !== void 0) {
+      fields.push("sort_order = ?");
+      values.push(body.sort_order);
+    }
+    if (fields.length) {
+      fields.push("updated_at = ?");
+      values.push(Date.now(), params.id);
+      db.prepare(`UPDATE threads SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+    }
+    send(res, 200, { thread: db.prepare("SELECT * FROM threads WHERE id = ?").get(params.id) });
   }
-
   delete(req, res, params) {
     const db = this.getActiveDb();
-    const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
-    db.prepare('DELETE FROM threads WHERE id = ?').run(params.id);
-    let sessionIdToDelete = thread.last_session_id;
-    const agentMatch = (thread.session_key || '').match(/^agent:([^:]+):/);
+    const thread = db.prepare("SELECT * FROM threads WHERE id = ?").get(params.id);
+    if (!thread) return sendError(res, 404, "Thread not found");
+    db.prepare("DELETE FROM threads WHERE id = ?").run(params.id);
+    const agentMatch = (thread.session_key || "").match(/^agent:([^:]+):/);
     const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    let sessionIdToDelete = thread.last_session_id;
     if (!sessionIdToDelete) {
       try {
-        const store = JSON.parse(fs.readFileSync(path.join(sessionsDir, 'sessions.json'), 'utf8'));
-        sessionIdToDelete = store[thread.session_key]?.sessionId;
-      } catch { /* ok */ }
+        sessionIdToDelete = JSON.parse(fs7.readFileSync(path8.join(sessionsDir, "sessions.json"), "utf8"))[thread.session_key]?.sessionId;
+      } catch {
+      }
     }
     cleanGatewaySession(thread.session_key);
     if (sessionIdToDelete) {
-      try { fs.unlinkSync(path.join(sessionsDir, `${sessionIdToDelete}.jsonl`)); } catch { /* ok */ }
+      try {
+        fs7.unlinkSync(path8.join(sessionsDir, `${sessionIdToDelete}.jsonl`));
+      } catch {
+      }
+    }
+    try {
+      fs7.rmSync(path8.join(this.uploadsDir, params.id), { recursive: true });
+    } catch {
     }
-    try { fs.rmSync(path.join(this.uploadsDir, params.id), { recursive: true }); } catch { /* ok */ }
     send(res, 200, { ok: true });
   }
+};
+
+// server/util/context.js
+import fs8 from "node:fs";
+import path9 from "node:path";
+function buildContextPreamble(db, threadId, lastSessionId, sessionKey) {
+  let summary = null;
+  let method = "raw";
+  if (lastSessionId) {
+    const agentMatch = (sessionKey || "").match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
+    try {
+      const lines = fs8.readFileSync(path9.join(sessionsDir, `${lastSessionId}.jsonl`), "utf8").split("\n").filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const entry = JSON.parse(lines[i]);
+          if (entry.type === "compaction" && entry.summary) {
+            summary = entry.summary;
+            method = "compaction";
+            break;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  let preamble = "";
+  if (method === "compaction" && summary) {
+    preamble += "[CONTEXT RECOVERY \u2014 This thread's agent session was reset. Below is a summary of the previous conversation followed by recent messages to restore context.]\n\n";
+    preamble += "[CONVERSATION SUMMARY]\n" + summary + "\n\n";
+    const msgs = db.prepare("SELECT role, content, timestamp FROM messages WHERE thread_id = ? ORDER BY timestamp DESC LIMIT 10").all(threadId).reverse();
+    if (msgs.length) {
+      preamble += "[RECENT MESSAGES]\n";
+      for (const m of msgs) {
+        const ts = new Date(m.timestamp).toISOString().replace("T", " ").slice(0, 16);
+        preamble += `${m.role.charAt(0).toUpperCase() + m.role.slice(1)} (${ts}): ${m.content}
+`;
+      }
+    }
+  } else {
+    preamble += "[CONTEXT RECOVERY \u2014 This thread's agent session was reset. Below are recent messages from the previous conversation to restore context.]\n\n";
+    const msgs = db.prepare("SELECT role, content, timestamp FROM messages WHERE thread_id = ? ORDER BY timestamp DESC LIMIT 25").all(threadId).reverse();
+    if (msgs.length) {
+      preamble += "[PREVIOUS MESSAGES]\n";
+      for (const m of msgs) {
+        const ts = new Date(m.timestamp).toISOString().replace("T", " ").slice(0, 16);
+        preamble += `${m.role.charAt(0).toUpperCase() + m.role.slice(1)} (${ts}): ${m.content}
+`;
+      }
+    }
+  }
+  if (preamble.length > MAX_PREAMBLE_CHARS) preamble = preamble.slice(preamble.length - MAX_PREAMBLE_CHARS);
+  return { preamble, method };
 }
+__name(buildContextPreamble, "buildContextPreamble");
 
-class MessageController {
+// server/controllers/messages.js
+var MessageController = class {
+  static {
+    __name(this, "MessageController");
+  }
   constructor({ getActiveDb, getWorkspaces, broadcast }) {
     this.getActiveDb = getActiveDb;
     this.getWorkspaces = getWorkspaces;
     this.broadcast = broadcast;
   }
-
   getAll(req, res, params, query) {
     const db = this.getActiveDb();
-    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
-    const limit = Math.min(parseInt(query.limit || '100', 10), 500);
+    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
+    const limit = Math.min(parseInt(query.limit || "100", 10), 500);
     const before = query.before ? parseInt(query.before, 10) : null;
     const after = query.after ? parseInt(query.after, 10) : null;
-    let sql = 'SELECT * FROM messages WHERE thread_id = ?';
+    let sql = "SELECT * FROM messages WHERE thread_id = ?";
     const sqlParams = [params.id];
-    if (before) { sql += ' AND timestamp < ?'; sqlParams.push(before); }
-    if (after) { sql += ' AND timestamp > ?'; sqlParams.push(after); }
-    const total = db.prepare(sql.replace('SELECT *', 'SELECT COUNT(*) as c')).get(...sqlParams).c;
-    const rows = db.prepare(sql + ' ORDER BY timestamp DESC LIMIT ?').all(...sqlParams, limit + 1);
-    const hasMore = rows.length > limit;
+    if (before) {
+      sql += " AND timestamp < ?";
+      sqlParams.push(before);
+    }
+    if (after) {
+      sql += " AND timestamp > ?";
+      sqlParams.push(after);
+    }
+    const total = db.prepare(sql.replace("SELECT *", "SELECT COUNT(*) as c")).get(...sqlParams).c;
+    const rows = db.prepare(sql + " ORDER BY timestamp DESC LIMIT ?").all(...sqlParams, limit + 1);
     const messages = rows.slice(0, limit).reverse();
-    for (const m of messages) { if (m.metadata) { try { m.metadata = JSON.parse(m.metadata); } catch { /* ok */ } } }
-    send(res, 200, { messages, hasMore });
+    for (const m of messages) {
+      if (m.metadata) {
+        try {
+          m.metadata = JSON.parse(m.metadata);
+        } catch {
+        }
+      }
+    }
+    send(res, 200, { messages, hasMore: rows.length > limit });
   }
-
   async create(req, res, params) {
     const body = await parseBody(req);
     const db = this.getActiveDb();
-    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
-    if (!body.id || !body.role || body.content === undefined || !body.timestamp) return sendError(res, 400, 'Required: id, role, content, timestamp');
+    if (!db.prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
+    if (!body.id || !body.role || body.content === void 0 || !body.timestamp) return sendError(res, 400, "Required: id, role, content, timestamp");
     const metadata = body.metadata ? JSON.stringify(body.metadata) : null;
-    const existing = db.prepare('SELECT id, status, metadata FROM messages WHERE id = ?').get(body.id);
+    const existing = db.prepare("SELECT id, status, metadata FROM messages WHERE id = ?").get(body.id);
     if (existing) {
       if (body.status && body.status !== existing.status) {
-        db.prepare('UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?').run(body.status, body.content, metadata || existing.metadata, body.id);
+        db.prepare("UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?").run(body.status, body.content, metadata || existing.metadata, body.id);
       }
     } else {
-      db.prepare('INSERT INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)').run(body.id, params.id, body.role, body.content, body.status || 'sent', metadata, body.seq || null, body.timestamp, Date.now());
-      db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(Date.now(), params.id);
-      if (body.role === 'user' && body.content) {
-        const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(params.id);
-        if (threadInfo?.title === 'New chat') {
-          const title = body.content.replace(/\n.*/s, '').slice(0, 40).trim() + (body.content.length > 40 ? '...' : '');
+      db.prepare("INSERT INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(body.id, params.id, body.role, body.content, body.status || "sent", metadata, body.seq || null, body.timestamp, Date.now());
+      db.prepare("UPDATE threads SET updated_at = ? WHERE id = ?").run(Date.now(), params.id);
+      if (body.role === "user" && body.content) {
+        const thread = db.prepare("SELECT title FROM threads WHERE id = ?").get(params.id);
+        if (thread?.title === "New chat") {
+          const title = body.content.replace(/\n.*/s, "").slice(0, 40).trim() + (body.content.length > 40 ? "..." : "");
           if (title) {
-            db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(title, params.id);
-            this.broadcast(JSON.stringify({ type: 'clawchats', event: 'thread-title-updated', threadId: params.id, workspace: this.getWorkspaces().active, title }));
+            db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(title, params.id);
+            this.broadcast(JSON.stringify({ type: "clawchats", event: "thread-title-updated", threadId: params.id, workspace: this.getWorkspaces().active, title }));
           }
         }
       }
     }
-    const message = db.prepare('SELECT * FROM messages WHERE id = ?').get(body.id);
-    if (message?.metadata) { try { message.metadata = JSON.parse(message.metadata); } catch { /* ok */ } }
+    const message = db.prepare("SELECT * FROM messages WHERE id = ?").get(body.id);
+    if (message?.metadata) {
+      try {
+        message.metadata = JSON.parse(message.metadata);
+      } catch {
+      }
+    }
     send(res, existing ? 200 : 201, { message });
   }
-
   delete(req, res, params) {
     const db = this.getActiveDb();
-    if (!db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(params.messageId, params.id)) return sendError(res, 404, 'Message not found');
-    db.prepare('DELETE FROM messages WHERE id = ?').run(params.messageId);
+    if (!db.prepare("SELECT id FROM messages WHERE id = ? AND thread_id = ?").get(params.messageId, params.id)) return sendError(res, 404, "Message not found");
+    db.prepare("DELETE FROM messages WHERE id = ?").run(params.messageId);
     send(res, 200, { ok: true });
   }
-
   contextFill(req, res, params) {
     const db = this.getActiveDb();
-    const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
-    const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key);
-    send(res, 200, { preamble, method });
+    const thread = db.prepare("SELECT * FROM threads WHERE id = ?").get(params.id);
+    if (!thread) return sendError(res, 404, "Thread not found");
+    send(res, 200, buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key));
   }
-
   search(req, res, params, query) {
-    const db = this.getActiveDb();
-    const q = query.q || '';
+    const q = query.q || "";
     if (!q) return send(res, 200, { results: [], total: 0 });
-    const page = parseInt(query.page || '1', 10);
-    const limit = Math.min(parseInt(query.limit || '20', 10), 100);
+    const db = this.getActiveDb();
+    const page = parseInt(query.page || "1", 10);
+    const limit = Math.min(parseInt(query.limit || "20", 10), 100);
     const offset = (page - 1) * limit;
     try {
       const results = db.prepare(`SELECT m.id as messageId, m.thread_id as threadId, t.title as threadTitle, m.role, snippet(messages_fts, 0, '<mark>', '</mark>', '...', 40) as content, m.timestamp FROM messages_fts JOIN messages m ON messages_fts.rowid = m.rowid JOIN threads t ON m.thread_id = t.id WHERE messages_fts MATCH ? ORDER BY rank LIMIT ? OFFSET ?`).all(q, limit, offset);
       const total = db.prepare(`SELECT COUNT(*) as c FROM messages_fts WHERE messages_fts MATCH ?`).get(q).c;
       send(res, 200, { results, total });
-    } catch { send(res, 200, { results: [], total: 0 }); }
+    } catch {
+      send(res, 200, { results: [], total: 0 });
+    }
   }
-
   export(req, res) {
     const db = this.getActiveDb();
     const ws = this.getWorkspaces();
-    const threads = db.prepare('SELECT * FROM threads ORDER BY updated_at DESC').all();
+    const threads = db.prepare("SELECT * FROM threads ORDER BY updated_at DESC").all();
     send(res, 200, {
-      workspace: ws.active, exportedAt: Date.now(),
-      threads: threads.map(t => {
-        const messages = db.prepare('SELECT * FROM messages WHERE thread_id = ? ORDER BY timestamp ASC').all(t.id);
-        for (const m of messages) { if (m.metadata) { try { m.metadata = JSON.parse(m.metadata); } catch { /* ok */ } } }
+      workspace: ws.active,
+      exportedAt: Date.now(),
+      threads: threads.map((t) => {
+        const messages = db.prepare("SELECT * FROM messages WHERE thread_id = ? ORDER BY timestamp ASC").all(t.id);
+        for (const m of messages) {
+          if (m.metadata) {
+            try {
+              m.metadata = JSON.parse(m.metadata);
+            } catch {
+            }
+          }
+        }
         return { ...t, messages };
-      }),
+      })
     });
   }
-
   async import(req, res) {
     const body = await parseBody(req);
     const db = this.getActiveDb();
     const ws = this.getWorkspaces();
-    if (!body.threads || !Array.isArray(body.threads)) return sendError(res, 400, 'Expected { threads: [...] }');
+    if (!body.threads || !Array.isArray(body.threads)) return sendError(res, 400, "Expected { threads: [...] }");
     let threadsImported = 0, messagesImported = 0;
-    const insertThread = db.prepare('INSERT OR IGNORE INTO threads (id, session_key, title, pinned, pin_order, model, last_session_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
-    const insertMsg = db.prepare('INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
-    db.transaction(() => {
+    const insertThread = db.prepare("INSERT OR IGNORE INTO threads (id, session_key, title, pinned, pin_order, model, last_session_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    const insertMsg = db.prepare("INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    db.exec("BEGIN");
+    try {
       for (const t of body.threads) {
         if (!t.id) continue;
         const sessionKey = t.session_key || `agent:main:${ws.active}:chat:${t.id}`;
-        if (insertThread.run(t.id, sessionKey, t.title || 'Imported chat', t.pinned || 0, t.pin_order || 0, t.model || null, t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now()).changes > 0) threadsImported++;
-        for (const m of (t.messages || [])) {
+        if (insertThread.run(t.id, sessionKey, t.title || "Imported chat", t.pinned || 0, t.pin_order || 0, t.model || null, t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now()).changes > 0) threadsImported++;
+        for (const m of t.messages || []) {
           if (!m.id || !m.role) continue;
-          const meta = m.metadata ? (typeof m.metadata === 'string' ? m.metadata : JSON.stringify(m.metadata)) : null;
-          if (insertMsg.run(m.id, t.id, m.role, m.content || '', m.status || 'sent', meta, m.seq || null, m.timestamp || Date.now(), m.created_at || Date.now()).changes > 0) messagesImported++;
+          const meta = m.metadata ? typeof m.metadata === "string" ? m.metadata : JSON.stringify(m.metadata) : null;
+          if (insertMsg.run(m.id, t.id, m.role, m.content || "", m.status || "sent", meta, m.seq || null, m.timestamp || Date.now(), m.created_at || Date.now()).changes > 0) messagesImported++;
         }
       }
-    })();
-    send(res, 200, { ok: true, threadsImported, messagesImported });
-  }
-}
-
-class FileController {
-  constructor({ getActiveDb, getWorkspaces, uploadsDir, intelligenceDir }) {
-    this.getActiveDb = getActiveDb;
-    this.getWorkspaces = getWorkspaces;
-    this.uploadsDir = uploadsDir;
-    this.intelligenceDir = intelligenceDir;
-  }
-
-  async upload(req, res, params) {
-    const db = this.getActiveDb();
-    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
-    const files = await parseMultipart(req);
-    const dir = path.join(this.uploadsDir, params.id);
-    fs.mkdirSync(dir, { recursive: true });
-    const savedFiles = [];
-    for (const file of files) {
-      const fileId = uuid();
-      const ext = path.extname(file.filename) || '';
-      const savedPath = path.join(dir, fileId + ext);
-      fs.writeFileSync(savedPath, file.data);
-      savedFiles.push({ id: fileId, filename: file.filename, path: `/api/uploads/${params.id}/${fileId}${ext}`, mimeType: file.mimeType, size: file.data.length });
-    }
-    send(res, 200, { files: savedFiles });
-  }
-
-  serveUpload(req, res, params) {
-    const base = path.join(this.uploadsDir, params.threadId, params.fileId);
-    let resolved = base;
-    if (!fs.existsSync(resolved)) {
-      try {
-        const match = fs.readdirSync(path.join(this.uploadsDir, params.threadId)).find(e => e.startsWith(params.fileId.replace(/\.[^.]+$/, '')));
-        if (match) resolved = path.join(this.uploadsDir, params.threadId, match);
-      } catch { /* ok */ }
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
     }
-    if (!fs.existsSync(resolved)) return sendError(res, 404, 'File not found');
-    const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.pdf': 'application/pdf', '.txt': 'text/plain', '.json': 'application/json' };
-    const stat = fs.statSync(resolved);
-    res.writeHead(200, { 'Content-Type': MIME[path.extname(resolved).toLowerCase()] || 'application/octet-stream', 'Content-Length': stat.size, 'Cache-Control': 'public, max-age=86400', 'Access-Control-Allow-Origin': '*' });
-    fs.createReadStream(resolved).pipe(res);
-  }
-
-  _intelligencePath(threadId) {
-    return path.join(this.intelligenceDir, this.getWorkspaces().active, `${threadId}.json`);
+    send(res, 200, { ok: true, threadsImported, messagesImported });
   }
+};
 
-  getIntelligence(req, res, params) {
-    const filePath = this._intelligencePath(params.id);
-    if (!fs.existsSync(filePath)) return send(res, 200, { versions: [], currentVersion: -1 });
-    try { return send(res, 200, JSON.parse(fs.readFileSync(filePath, 'utf8'))); }
-    catch { return send(res, 200, { versions: [], currentVersion: -1 }); }
-  }
+// server/controllers/files.js
+import fs9 from "node:fs";
+import path10 from "node:path";
 
-  async saveIntelligence(req, res, params) {
-    const body = await parseBody(req);
-    const filePath = this._intelligencePath(params.id);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const data = { versions: body.versions || [], currentVersion: body.currentVersion ?? -1, updatedAt: Date.now() };
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    send(res, 200, data);
-  }
-}
-
-class MemoryController {
-  constructor({ memoryProvider, memoryFilesDir, memoryConfig }) {
-    this.provider = memoryProvider;
-    this.filesDir = memoryFilesDir;
-    this.config = memoryConfig;
-  }
-
-  async list(req, res, query) {
-    const limit = Math.min(parseInt(query.limit) || 20, 100);
-    try { send(res, 200, await this.provider.list(limit, query.offset || null)); }
-    catch (err) { send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message }); }
-  }
-
-  async search(req, res, query) {
-    const q = (query.query || '').toLowerCase().trim();
-    if (!q) return send(res, 400, { error: 'Missing query parameter' });
-    try { send(res, 200, await this.provider.search(q)); }
-    catch (err) { send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message }); }
-  }
-
-  files(req, res, query) {
-    const q = (query.query || '').toLowerCase().trim();
-    const memories = this._parseFiles();
-    const filtered = q ? memories.filter(m => m.data.toLowerCase().includes(q) || m.title.toLowerCase().includes(q)) : memories;
-    filtered.sort((a, b) => (b.createdAt || '').localeCompare(a.createdAt || ''));
-    send(res, 200, { memories: filtered });
-  }
-
-  _parseFiles() {
-    const memories = [];
-    const scanDir = (dir, prefix = '') => {
-      let entries;
-      try { entries = fs.readdirSync(dir); } catch { return; }
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry);
-        const stat = (() => { try { return fs.statSync(fullPath); } catch { return null; } })();
-        if (!stat) continue;
-        if (stat.isDirectory() && !prefix) {
-          scanDir(fullPath, entry + '/');
-        } else if (entry.endsWith('.md') && stat.isFile()) {
-          const content = fs.readFileSync(fullPath, 'utf8');
-          const basename = entry.replace(/\.md$/, '');
-          const relName = prefix + basename;
-          const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})/);
-          if (prefix) {
-            memories.push({ id: `file:${relName}`, source: 'file', file: relName, title: basename, data: content.trim(), createdAt: stat.mtime.toISOString() });
-          } else {
-            const sections = content.split(/^(?=## )/m);
-            for (const section of sections) {
-              const trimmed = section.trim();
-              if (!trimmed) continue;
-              const headingMatch = trimmed.match(/^##\s+(.+)/);
-              const heading = headingMatch ? headingMatch[1].trim() : null;
-              const body = headingMatch ? trimmed.slice(trimmed.indexOf('\n') + 1).trim() : trimmed;
-              if (!heading && body.match(/^#\s+/) && body.split('\n').length <= 2) continue;
-              const title = heading || basename;
-              memories.push({ id: `file:${basename}:${title}`, source: 'file', file: basename, title, data: heading ? `**${title}**\n${body}` : body, createdAt: dateMatch ? `${dateMatch[1]}T00:00:00Z` : stat.mtime.toISOString() });
-            }
-          }
+// server/util/multipart.js
+function parseMultipart(req) {
+  return new Promise((resolve, reject) => {
+    const contentType = req.headers["content-type"] || "";
+    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
+    if (!boundaryMatch) return reject(new Error("No boundary in content-type"));
+    const boundary = boundaryMatch[1] || boundaryMatch[2];
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const buf = Buffer.concat(chunks);
+      const files = [];
+      const delimiter = Buffer.from(`--${boundary}`);
+      let pos = 0;
+      while (pos < buf.length) {
+        const start = buf.indexOf(delimiter, pos);
+        if (start === -1) break;
+        const nextStart = buf.indexOf(delimiter, start + delimiter.length);
+        if (nextStart === -1) break;
+        const part = buf.subarray(start + delimiter.length, nextStart);
+        const headerEnd = part.indexOf("\r\n\r\n");
+        if (headerEnd === -1) {
+          pos = nextStart;
+          continue;
+        }
+        const headerStr = part.subarray(0, headerEnd).toString();
+        let body = part.subarray(headerEnd + 4);
+        if (body.length >= 2 && body[body.length - 2] === 13 && body[body.length - 1] === 10) {
+          body = body.subarray(0, body.length - 2);
+        }
+        const filenameMatch = headerStr.match(/filename="([^"]+)"/);
+        const ctMatch = headerStr.match(/Content-Type:\s*(\S+)/i);
+        if (filenameMatch) {
+          files.push({
+            filename: filenameMatch[1],
+            mimeType: ctMatch ? ctMatch[1] : "application/octet-stream",
+            data: body
+          });
         }
+        pos = nextStart;
       }
-    };
-    scanDir(this.filesDir);
-    return memories;
-  }
-
-  async update(req, res, params) {
-    try {
-      const chunks = [];
-      for await (const chunk of req) chunks.push(chunk);
-      const { data } = JSON.parse(Buffer.concat(chunks).toString());
-      if (!(data || '').trim()) return send(res, 400, { error: 'Missing data field' });
-      send(res, 200, { ok: true, result: await this.provider.update(params.id, data.trim()) });
-    } catch (err) { send(res, 502, { error: 'Failed to update memory', detail: err.message }); }
-  }
-
-  async delete(req, res, params) {
-    try { send(res, 200, { ok: true, result: await this.provider.delete(params.id) }); }
-    catch (err) { send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message }); }
-  }
-
-  async status(req, res) {
-    const status = await this.provider.status();
-    send(res, 200, { provider: this.provider.name, host: this.config.host, port: this.config.port, collection: this.config.collection, backend: status, memoryFilesDir: this.filesDir, memoryFilesDirExists: fs.existsSync(this.filesDir) });
-  }
-}
-
-// ─── Shared helpers (used by _GatewayClient inside createApp) ────────────────
-
-function syncThreadUnreadCount(db, threadId) {
-  const count = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(threadId).c;
-  db.prepare('UPDATE threads SET unread_count = ? WHERE id = ?').run(count, threadId);
-  return count;
-}
-
-function parseSessionKey(sessionKey) {
-  if (!sessionKey) return null;
-  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
-  if (!match) return null;
-  return { agent: match[1], workspace: match[2], threadId: match[3] };
-}
-
-function extractContent(message) {
-  if (!message) return '';
-  if (typeof message.content === 'string') return message.content;
-  if (Array.isArray(message.content)) {
-    return message.content.filter(p => p.type === 'text').map(p => p.text).join('');
-  }
-  return '';
-}
-
-function isSilentReplyExact(text, token = 'NO_REPLY') {
-  if (!text) return false;
-  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
-}
-
-function isSilentReplyPrefix(text, token = 'NO_REPLY') {
-  if (!text) return false;
-  const trimmed = text.trimStart();
-  if (!trimmed) return false;
-  if (trimmed !== trimmed.toUpperCase()) return false;
-  const normalized = trimmed.toUpperCase();
-  if (normalized.length < 2) return false;
-  if (/[^A-Z_]/.test(normalized)) return false;
-  const tokenUpper = token.toUpperCase();
-  if (!tokenUpper.startsWith(normalized)) return false;
-  if (normalized.includes('_')) return true;
-  return tokenUpper === 'NO_REPLY' && normalized === 'NO';
-}
-
-function stripTrailingSentinel(text, token = 'NO_REPLY') {
-  if (!text) return text;
-  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), '').trim();
-}
-
-function stripFinalTags(text) {
-  if (!text) return text;
-  return text.replace(/<\s*\/?\s*final\s*>/gi, '');
-}
-
-function sanitizeAssistantContent(text) {
-  if (!text) return text;
-  let out = stripFinalTags(text);
-  out = out.replace(/^(?:[ \t]*\r?\n)+/, '');
-  if (out.includes('NO_REPLY'))     out = stripTrailingSentinel(out, 'NO_REPLY');
-  if (out.includes('HEARTBEAT_OK')) out = stripTrailingSentinel(out, 'HEARTBEAT_OK');
-  return out;
-}
-
-function generateActivitySummary(steps) {
-  const toolSteps = steps.filter(s => s.type === 'tool' && s.phase !== 'result' && s.phase !== 'update');
-  const hasThinking = steps.some(s => s.type === 'thinking' && s.text);
-  const hasNarration = steps.some(s => s.type === 'assistant' && s.text?.trim());
-  if (toolSteps.length === 0 && !hasThinking && !hasNarration) return null;
-  if (toolSteps.length === 0 && hasThinking) return 'Reasoned through the problem';
-  if (toolSteps.length === 0 && hasNarration) return 'Processed in multiple steps';
-  const counts = {};
-  for (const s of toolSteps) { const name = s.name || 'unknown'; counts[name] = (counts[name] || 0) + 1; }
-  const toolNames = { web_search:'searched the web', web_fetch:'fetched web pages', Read:'read files', read:'read files', Write:'wrote files', write:'wrote files', Edit:'edited files', edit:'edited files', exec:'ran commands', Bash:'ran commands', browser:'browsed the web', memory_search:'searched memory', memory_store:'saved to memory', image:'analyzed images', message:'sent messages', sessions_spawn:'spawned sub-agents', cron:'managed cron jobs', Grep:'searched code', grep:'searched code', Glob:'found files', glob:'found files' };
-  const parts = [];
-  for (const [name, count] of Object.entries(counts)) {
-    const friendly = toolNames[name];
-    parts.push(friendly ? (count > 1 ? `${friendly} (${count}×)` : friendly) : (count > 1 ? `used ${name} (${count}×)` : `used ${name}`));
-  }
-  if (parts.length === 0) return null;
-  if (parts.length === 1) return parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
-  const last = parts.pop();
-  return (parts.join(', ') + ' and ' + last).replace(/^./, c => c.toUpperCase());
-}
-
-function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
-  if (!log._parsed) log._parsed = parseSessionKey(log.sessionKey);
-  const parsed = log._parsed;
-  if (!parsed) return;
-  const db = getDbFn(parsed.workspace);
-  if (!db) return;
-  const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
-  const summary = generateActivitySummary(log.steps);
-  const now = Date.now();
-  if (!log._messageId) {
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
-    if (!thread) return;
-    const messageId = `gw-activity-${runId}`;
-    const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
-    try {
-      db.prepare(`INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)`).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
-      log._messageId = messageId;
-      broadcastFn(JSON.stringify({ type: 'clawchats', event: 'message-saved', threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now }));
-    } catch (err) { console.error(`[activity] Failed to write activity ${messageId}:`, err.message); }
-  } else {
-    const existing = db.prepare('SELECT metadata FROM messages WHERE id = ?').get(log._messageId);
-    const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
-    metadata.activityLog = cleanSteps;
-    metadata.activitySummary = summary;
-    metadata.pending = true;
-    db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), log._messageId);
-  }
+      resolve(files);
+    });
+    req.on("error", reject);
+  });
 }
+__name(parseMultipart, "parseMultipart");
 
-// ─── createApp Factory ───────────────────────────────────────────────────────
-// Returns an isolated instance of the app state + handlers.
-// Used by the plugin (signaling/index.js) to embed ClawChats logic without
-// spinning up a standalone HTTP server.
-
-export function createApp(config = {}) {
-  // ── Config-dependent constants ─────────────────────────────────────────────
-  const _DATA_DIR = config.dataDir || path.join(__dirname, 'data');
-  const _UPLOADS_DIR = config.uploadsDir || path.join(__dirname, 'uploads');
-  const _WORKSPACES_FILE = path.join(_DATA_DIR, 'workspaces.json');
-  const _SETTINGS_FILE = path.join(_DATA_DIR, 'settings.json');
-  const _INTELLIGENCE_DIR = path.join(_DATA_DIR, 'intelligence');
-
-  let _AUTH_TOKEN = config.authToken !== undefined
-    ? config.authToken
-    : (process.env.CLAWCHATS_AUTH_TOKEN || process.env.SHELLCHAT_AUTH_TOKEN || parseConfigField('authToken') || '');
-
-  // Separate token for gateway WS auth (falls back to _AUTH_TOKEN for direct mode)
-  const _GATEWAY_TOKEN = config.gatewayToken !== undefined
-    ? config.gatewayToken
-    : _AUTH_TOKEN;
-
-  const _GATEWAY_WS_URL = config.gatewayUrl || discoverGatewayWsUrl();
-
-  // ── Mutable singleton state ────────────────────────────────────────────────
-  const _dbCache = new Map();
-  let _workspacesConfig = null;
-  const _debugLogger = new DebugLogger(_DATA_DIR);
-
-  const _MEMORY_CONFIG = discoverMemoryConfig();
-  const _memoryProvider = createMemoryProvider(_MEMORY_CONFIG);
-  _memoryProvider.init().catch(err => console.error('[createApp] Memory provider init error:', err.message));
-
-  const _MEMORY_FILES_DIR = path.join(_MEMORY_CONFIG.workspaceDir, 'memory');
-
-  // ── Workspace helpers ──────────────────────────────────────────────────────
-  function _loadWorkspaces() {
-    try {
-      return JSON.parse(fs.readFileSync(_WORKSPACES_FILE, 'utf8'));
-    } catch {
-      const initial = {
-        active: 'default',
-        workspaces: {
-          default: { name: 'default', label: 'Default', createdAt: Date.now() }
-        }
-      };
-      fs.writeFileSync(_WORKSPACES_FILE, JSON.stringify(initial, null, 2));
-      return initial;
-    }
-  }
-
-  function _saveWorkspaces(data) {
-    fs.writeFileSync(_WORKSPACES_FILE, JSON.stringify(data, null, 2));
-  }
-
-  function _getWorkspaces() {
-    if (!_workspacesConfig) _workspacesConfig = _loadWorkspaces();
-    return _workspacesConfig;
-  }
-
-  function _setWorkspaces(data) {
-    _workspacesConfig = data;
-    _saveWorkspaces(data);
-  }
-
-  // ── Database helpers ───────────────────────────────────────────────────────
-  function _getDb(workspaceName) {
-    if (_dbCache.has(workspaceName)) return _dbCache.get(workspaceName);
-    const dbPath = path.join(_DATA_DIR, `${workspaceName}.db`);
-    const db = new Database(dbPath);
-    db.pragma('journal_mode = WAL');
-    db.pragma('foreign_keys = ON');
-    migrate(db);
-    _dbCache.set(workspaceName, db);
-    return db;
-  }
-
-  function _getActiveDb() {
-    return _requestDbStore.getStore() || _getDb(_getWorkspaces().active);
-  }
-
-  function _closeDb(workspaceName) {
-    const db = _dbCache.get(workspaceName);
-    if (db) { db.close(); _dbCache.delete(workspaceName); }
-  }
-
-  function _closeAllDbs() {
-    for (const [, db] of _dbCache) db.close();
-    _dbCache.clear();
+// server/controllers/files.js
+var FileController = class {
+  static {
+    __name(this, "FileController");
   }
-
-  function _ensureDirs() {
-    fs.mkdirSync(_DATA_DIR, { recursive: true });
-    fs.mkdirSync(_UPLOADS_DIR, { recursive: true });
+  constructor({ getActiveDb, getWorkspaces, uploadsDir, intelligenceDir }) {
+    this.getActiveDb = getActiveDb;
+    this.getWorkspaces = getWorkspaces;
+    this.uploadsDir = uploadsDir;
+    this.intelligenceDir = intelligenceDir;
   }
-
-  // ── Auth (closes over _AUTH_TOKEN) ─────────────────────────────────────────
-  function _checkAuth(req, res) {
-    if (!_AUTH_TOKEN) return true;
-    const auth = req.headers.authorization;
-    if (!auth || !auth.startsWith('Bearer ')) {
-      sendError(res, 401, 'Missing or invalid Authorization header');
-      return false;
-    }
-    const token = auth.slice(7);
-    if (token !== _AUTH_TOKEN) {
-      sendError(res, 401, 'Invalid auth token');
-      return false;
+  async upload(req, res, params) {
+    if (!this.getActiveDb().prepare("SELECT id FROM threads WHERE id = ?").get(params.id)) return sendError(res, 404, "Thread not found");
+    const files = await parseMultipart(req);
+    const dir = path10.join(this.uploadsDir, params.id);
+    fs9.mkdirSync(dir, { recursive: true });
+    const savedFiles = [];
+    for (const file of files) {
+      const fileId = uuid();
+      const ext = path10.extname(file.filename) || "";
+      fs9.writeFileSync(path10.join(dir, fileId + ext), file.data);
+      savedFiles.push({ id: fileId, filename: file.filename, path: `/api/uploads/${params.id}/${fileId}${ext}`, mimeType: file.mimeType, size: file.data.length });
     }
-    return true;
+    send(res, 200, { files: savedFiles });
   }
-
-  // ── GatewayClient (scoped to this factory instance) ───────────────────────
-  class _GatewayClient {
-    constructor() {
-      this.ws = null;
-      this.connected = false;
-      this.reconnectAttempts = 0;
-      this.maxReconnectDelay = 30000;
-      this.browserClients = new Map();
-      this._externalBroadcastTargets = [];
-      this.streamState = new Map();
-      this.activityLogs = new Map();
-      setInterval(() => {
-        const cutoff = Date.now() - 10 * 60 * 1000;
-        for (const [runId, log] of this.activityLogs) {
-          if (log.startTime < cutoff) {
-            if (log._messageId) {
-              const db = _getDb(log._parsed?.workspace);
-              if (db) {
-                db.prepare(`
-                  UPDATE messages SET content = '[Response interrupted]',
-                  metadata = json_remove(metadata, '$.pending')
-                  WHERE id = ? AND content = ''
-                `).run(log._messageId);
-              }
-            }
-            this.activityLogs.delete(runId);
-          }
-        }
-      }, 5 * 60 * 1000);
-    }
-
-    connect() {
-      if (this.ws && (this.ws.readyState === WS.CONNECTING || this.ws.readyState === WS.OPEN)) return;
-      console.log(`Connecting to gateway at ${_GATEWAY_WS_URL}...`);
-      this.ws = new WS(_GATEWAY_WS_URL);
-      this.ws.on('open', () => { console.log('Gateway WebSocket connected'); this.reconnectAttempts = 0; });
-      this.ws.on('message', (data) => { this.handleGatewayMessage(data.toString()); });
-      this.ws.on('close', () => { console.log('Gateway WebSocket closed'); this.connected = false; this.broadcastGatewayStatus(false); this.scheduleReconnect(); });
-      this.ws.on('error', (err) => { console.error('Gateway WebSocket error:', err.message); });
-    }
-
-    handleGatewayMessage(data) {
-      _debugLogger.logFrame('GW→SRV', data);
-      let msg;
-      try { msg = JSON.parse(data); } catch { console.error('Invalid JSON from gateway:', data); return; }
-      if (msg.type === 'event' && msg.event === 'connect.challenge') {
-        console.log('Received connect.challenge, sending auth...');
-        const _nonce = msg.payload?.nonce || '';
-        const _identityPath = path.join(_DATA_DIR, 'device-identity.json');
-        const _identity = _loadOrCreateDeviceIdentity(_identityPath);
-        const _device = _buildDeviceAuth(_identity, {
-          clientId: 'gateway-client', clientMode: 'backend', role: 'operator',
-          scopes: ['operator.read', 'operator.write', 'operator.admin'], token: _GATEWAY_TOKEN, nonce: _nonce
-        });
-        this.ws.send(JSON.stringify({ type: 'req', id: 'gw-connect-1', method: 'connect', params: { minProtocol: 3, maxProtocol: 3, client: { id: 'gateway-client', version: '0.1.0', platform: 'node', mode: 'backend' }, role: 'operator', scopes: ['operator.read', 'operator.write', 'operator.admin'], device: _device, auth: { token: _GATEWAY_TOKEN }, caps: ['tool-events'] } }));
-        return;
-      }
-      if (msg.type === 'res' && msg.payload?.type === 'hello-ok') { console.log('Gateway handshake complete'); this.connected = true; this.broadcastGatewayStatus(true); }
-      // Chat events are routed through handleChatEvent which decides when/if to
-      // broadcast (sentinel hold, flush ordering, suppression). All other events
-      // broadcast unconditionally.
-      if (msg.type === 'event' && msg.event === 'chat' && msg.payload) {
-        this.handleChatEvent(msg.payload, data);
-      } else {
-        this.broadcastToBrowsers(data);
-      }
-      if (msg.type === 'event' && msg.event === 'agent' && msg.payload) this.handleAgentEvent(msg.payload);
-    }
-
-    handleChatEvent(params, rawData) {
-      const { sessionKey, state, message, seq } = params;
-
-      if (state === 'delta') {
-        const parsed = parseSessionKey(sessionKey);
-        if (parsed) {
-          const existing = this.streamState.get(sessionKey) || { buffer: '', threadId: parsed.threadId, state: 'streaming', held: [] };
-          existing.buffer += extractContent(message);
-
-          // If the accumulated buffer looks like a NO_REPLY or HEARTBEAT_OK prefix,
-          // hold this raw delta — don't forward to browsers yet.
-          if (isSilentReplyPrefix(existing.buffer, 'NO_REPLY') || isSilentReplyPrefix(existing.buffer, 'HEARTBEAT_OK')) {
-            existing.held = existing.held || [];
-            existing.held.push(rawData);
-            this.streamState.set(sessionKey, existing);
-            return; // suppressed — wait for more chunks
-          }
-
-          // Buffer diverged from any sentinel — flush held deltas first, then current.
-          if (existing.held?.length > 0) {
-            for (const h of existing.held) this.broadcastToBrowsers(h);
-            existing.held = [];
-          }
-          this.streamState.set(sessionKey, existing);
-        }
-        this.broadcastToBrowsers(rawData);
-        return;
-      }
-
-      // Capture stream entry before deletion so we can flush held deltas if needed.
-      const streamEntry = this.streamState.get(sessionKey);
-      if (state === 'final' || state === 'aborted' || state === 'error') this.streamState.delete(sessionKey);
-
-      // Title generation sessions: pass through without sentinel filtering.
-      if (sessionKey && sessionKey.includes('__clawchats_title_')) {
-        if (state === 'final') {
-          const content = extractContent(message);
-          if (content && this.handleTitleResponse(sessionKey, content)) return;
-        } else if (state === 'error' || state === 'aborted') {
-          if (this._pendingTitleGens) {
-            for (const key of this._pendingTitleGens.keys()) {
-              if (sessionKey === key || sessionKey.includes(key)) { this._pendingTitleGens.delete(key); break; }
-            }
-          }
-          return;
-        }
-      }
-
-      if (state === 'final') {
-        const rawContent = extractContent(message);
-
-        // Exact NO_REPLY or HEARTBEAT_OK — suppress entirely. Discard any held deltas,
-        // don't broadcast the final event, don't save to DB.
-        if (isSilentReplyExact(rawContent, 'NO_REPLY') || isSilentReplyExact(rawContent, 'HEARTBEAT_OK')) {
-          return;
-        }
-
-        // If we held deltas (buffer was a sentinel prefix), flush them before the final
-        // so the browser has a response element ready for finalization.
-        if (streamEntry?.held?.length > 0) {
-          for (const h of streamEntry.held) this.broadcastToBrowsers(h);
-        }
-
-        // Broadcast the final event, then persist.
-        this.broadcastToBrowsers(rawData);
-        this.saveAssistantMessage(sessionKey, message, seq);
-        return;
-      }
-
-      if (state === 'aborted' || state === 'error') {
-        // Discard any held deltas silently — if stream was aborted while holding a
-        // NO_REPLY prefix, there's nothing to show. Broadcast the terminal event normally.
-        this.broadcastToBrowsers(rawData);
-      }
-
-      if (state === 'error') this.saveErrorMarker(sessionKey, message);
-    }
-
-    saveAssistantMessage(sessionKey, message, seq) {
-      const parsed = parseSessionKey(sessionKey);
-      if (!parsed) return;
-      const ws = _getWorkspaces();
-      if (!ws.workspaces[parsed.workspace]) { console.log(`Ignoring response for deleted workspace: ${parsed.workspace}`); return; }
-      const db = _getDb(parsed.workspace);
-      const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
-      if (!thread) { console.log(`Ignoring response for deleted thread: ${parsed.threadId}`); return; }
-      let content = sanitizeAssistantContent(extractContent(message));
-      if (!content || !content.trim()) { console.log(`Skipping empty assistant response for thread ${parsed.threadId}`); return; }
-
-      // Attach media captured by the after_tool_call hook (MEDIA: lines from exec stdout).
-      // Classify by extension: images → inline markdown, audio/docs → metadata.attachments.
-      // Always clear the stash regardless of whether paths were found (prevents cross-turn leaks).
-      const _mediaStash = config.mediaStash;
-      const _pendingPaths = _mediaStash?.get(sessionKey) ?? [];
-      _mediaStash?.delete(sessionKey);
-      const _IMAGE_EXTS = new Set(['png','jpg','jpeg','gif','webp','bmp','svg','ico','avif','tiff']);
-      const _AUDIO_EXTS = new Set(['mp3','wav','ogg','m4a','flac','aac','opus','wma']);
-      const _pendingAttachments = []; // non-image files → metadata.attachments
-      const imagePaths = []; // images → inline markdown (declared outside if for broadcast scope)
-      if (_pendingPaths.length > 0) {
-        for (const p of _pendingPaths) {
-          const ext = (p.split('.').pop() || '').toLowerCase();
-          if (_IMAGE_EXTS.has(ext)) {
-            imagePaths.push(p);
-          } else {
-            const name = p.split('/').pop();
-            const type = _AUDIO_EXTS.has(ext) ? 'audio' : 'file';
-            _pendingAttachments.push({ path: p, name, type });
-          }
-        }
-        if (imagePaths.length > 0) {
-          content = content.trimEnd() + '\n\n' + imagePaths.map(p => `![image](${p})`).join('\n');
-        }
-        console.log(`[clawchats] media-attach: ${imagePaths.length} image(s) inline, ${_pendingAttachments.length} attachment(s) for ${sessionKey}`);
-      }
-
-      const now = Date.now();
-
-      // Check for pending activity message
-      const pendingMsg = db.prepare(`
-        SELECT id, metadata FROM messages
-        WHERE thread_id = ? AND role = 'assistant'
-        AND json_extract(metadata, '$.pending') = 1
-        ORDER BY timestamp DESC LIMIT 1
-      `).get(parsed.threadId);
-
-      let messageId;
-
-      if (pendingMsg) {
-        // Merge final content into existing activity row
-        const metadata = pendingMsg.metadata ? JSON.parse(pendingMsg.metadata) : {};
-        delete metadata.pending;
-        if (metadata.activityLog) {
-          const lastAssistantIdx = metadata.activityLog.findLastIndex(s => s.type === 'assistant');
-          if (lastAssistantIdx >= 0) metadata.activityLog.splice(lastAssistantIdx, 1);
-          metadata.activitySummary = this.generateActivitySummary(metadata.activityLog);
-        }
-        if (_pendingAttachments.length > 0) {
-          metadata.attachments = [...(metadata.attachments || []), ..._pendingAttachments];
-        }
-        db.prepare('UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?')
-          .run(content, JSON.stringify(metadata), now, pendingMsg.id);
-        messageId = pendingMsg.id;
-      } else {
-        // No pending activity — normal INSERT (simple responses, no tools)
-        messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
-        const newMeta = _pendingAttachments.length > 0 ? JSON.stringify({ attachments: _pendingAttachments }) : null;
-        db.prepare(`INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', ?, 'sent', ?, ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, metadata = COALESCE(excluded.metadata, metadata), timestamp = excluded.timestamp`).run(messageId, parsed.threadId, content, newMeta, now, now);
-      }
-
-      try {
-        db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(now, parsed.threadId);
-        db.prepare('INSERT OR IGNORE INTO unread_messages (thread_id, message_id, created_at) VALUES (?, ?, ?)').run(parsed.threadId, messageId, now);
-        syncThreadUnreadCount(db, parsed.threadId);
-        const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(parsed.threadId);
-        const unreadCount = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(parsed.threadId).c;
-        const preview = content.length > 120 ? content.substring(0, 120) + '...' : content;
-        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'message-saved', threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now, title: threadInfo?.title || 'Chat', preview, unreadCount, updatedContent: imagePaths.length > 0 ? content : undefined, updatedAttachments: _pendingAttachments.length > 0 ? _pendingAttachments : undefined }));
-        const workspaceUnreadTotal = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
-        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'unread-update', workspace: parsed.workspace, threadId: parsed.threadId, messageId, action: 'new', unreadCount, workspaceUnreadTotal, title: threadInfo?.title || 'Chat', preview, timestamp: now }));
-        console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (${pendingMsg ? 'merged into pending' : 'seq: ' + seq})`);
-
-        // Auto-generate AI title upgrade after first assistant response
-        const currentTitle = db.prepare('SELECT title FROM threads WHERE id = ?').get(parsed.threadId)?.title;
-        const msgCount = db.prepare('SELECT COUNT(*) as c FROM messages WHERE thread_id = ?').get(parsed.threadId).c;
-        if (msgCount === 2 || currentTitle === 'New chat') {
-          this.generateThreadTitle(db, parsed.threadId, parsed.workspace, true);
-        }
-      } catch (e) { console.error(`Failed to save assistant message:`, e.message); }
-    }
-
-    saveErrorMarker(sessionKey, message) {
-      const parsed = parseSessionKey(sessionKey);
-      if (!parsed) return;
-      const ws = _getWorkspaces();
-      if (!ws.workspaces[parsed.workspace]) return;
-      const db = _getDb(parsed.workspace);
-      const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
-      if (!thread) return;
-      const errorText = message?.error || message?.content || 'Unknown error';
-      const content = `[error] ${errorText}`;
-      const now = Date.now();
-      const messageId = `gw-error-${parsed.threadId}-${now}`;
+  serveUpload(req, res, params) {
+    const base = path10.join(this.uploadsDir, params.threadId, params.fileId);
+    let resolved = base;
+    if (!fs9.existsSync(resolved)) {
       try {
-        db.prepare('INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(messageId, parsed.threadId, 'system', content, 'sent', '{"transient":true}', now, now);
-        console.log(`Saved error marker for ${parsed.workspace}/${parsed.threadId}`);
-      } catch (e) { console.error(`Failed to save error marker:`, e.message); }
-    }
-
-    generateThreadTitle(db, threadId, workspace, skipHeuristic = false) {
-      const thread = db.prepare('SELECT title FROM threads WHERE id = ?').get(threadId);
-      if (!thread) return;
-      const titleKey = `__clawchats_title_${threadId}`;
-      if (this._pendingTitleGens?.has(titleKey)) return;
-      const firstUserMsg = db.prepare("SELECT content FROM messages WHERE thread_id = ? AND role = 'user' ORDER BY created_at ASC LIMIT 1").get(threadId);
-      if (!firstUserMsg?.content) return;
-
-      if (!skipHeuristic) {
-        const heuristic = firstUserMsg.content.replace(/\n.*/s, '').slice(0, 40).trim() + (firstUserMsg.content.length > 40 ? '...' : '');
-        db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(heuristic, threadId);
-        this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'thread-title-updated', threadId, workspace, title: heuristic }));
+        const match = fs9.readdirSync(path10.join(this.uploadsDir, params.threadId)).find((e) => e.startsWith(params.fileId.replace(/\.[^.]+$/, "")));
+        if (match) resolved = path10.join(this.uploadsDir, params.threadId, match);
+      } catch {
       }
-
-      const messages = db.prepare('SELECT role, content FROM messages WHERE thread_id = ? ORDER BY created_at ASC LIMIT 6').all(threadId);
-      if (messages.length < 2) return;
-      const conversation = messages.map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content.length > 300 ? m.content.slice(0, 300) + '...' : m.content}`).join('\n\n');
-      const prompt = `Based on this conversation, generate a concise 3-5 word title. Return ONLY the title text, no quotes, no explanation:\n\n${conversation}\n\nTitle:`;
-      const reqId = `title-${threadId}-${Date.now()}`;
-      if (!this._pendingTitleGens) this._pendingTitleGens = new Map();
-      this._pendingTitleGens.set(titleKey, { threadId, workspace, reqId });
-      setTimeout(() => { if (this._pendingTitleGens?.has(titleKey)) { this._pendingTitleGens.delete(titleKey); console.log(`Title gen timeout for ${threadId} — keeping heuristic title`); } }, 30000);
-      this.sendToGateway(JSON.stringify({ type: 'req', id: reqId, method: 'chat.send', params: { sessionKey: titleKey, message: prompt, deliver: false, idempotencyKey: reqId } }));
     }
+    if (!fs9.existsSync(resolved)) return sendError(res, 404, "File not found");
+    const MIME = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".pdf": "application/pdf", ".txt": "text/plain", ".json": "application/json" };
+    const stat = fs9.statSync(resolved);
+    res.writeHead(200, { "Content-Type": MIME[path10.extname(resolved).toLowerCase()] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*" });
+    fs9.createReadStream(resolved).pipe(res);
+  }
+  _intelligencePath(threadId) {
+    return path10.join(this.intelligenceDir, this.getWorkspaces().active, `${threadId}.json`);
+  }
+  getIntelligence(req, res, params) {
+    const filePath = this._intelligencePath(params.id);
+    if (!fs9.existsSync(filePath)) return send(res, 200, { versions: [], currentVersion: -1 });
+    try {
+      return send(res, 200, JSON.parse(fs9.readFileSync(filePath, "utf8")));
+    } catch {
+      return send(res, 200, { versions: [], currentVersion: -1 });
+    }
+  }
+  async saveIntelligence(req, res, params) {
+    const body = await parseBody(req);
+    const filePath = this._intelligencePath(params.id);
+    fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
+    const data = { versions: body.versions || [], currentVersion: body.currentVersion ?? -1, updatedAt: Date.now() };
+    fs9.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    send(res, 200, data);
+  }
+};
 
-    handleTitleResponse(sessionKey, content) {
-      if (!this._pendingTitleGens) return false;
-      // Gateway may prefix sessionKey (e.g. agent:main:__clawchats_title_xxx)
-      let matchKey = null, pending = null;
-      for (const [key, val] of this._pendingTitleGens) {
-        if (sessionKey === key || sessionKey.includes(key)) { matchKey = key; pending = val; break; }
-      }
-      if (!pending) return false;
-      this._pendingTitleGens.delete(matchKey);
-      let title = content.trim().replace(/^["']|["']$/g, '').replace(/^Title:\s*/i, '').replace(/\n.*/s, '').trim();
-      if (title.length > 50) title = title.substring(0, 47) + '...';
-      if (title.length === 0 || title.length >= 100) return true;
-      const db = _getDb(pending.workspace);
-      db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(title, pending.threadId);
-      this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'thread-title-updated', threadId: pending.threadId, workspace: pending.workspace, title }));
-      console.log(`AI title generated for ${pending.threadId}: "${title}"`);
-      return true;
+// server/controllers/memory.js
+import fs10 from "node:fs";
+import path11 from "node:path";
+var MemoryController = class {
+  static {
+    __name(this, "MemoryController");
+  }
+  constructor({ memoryProvider, memoryFilesDir, memoryConfig }) {
+    this.provider = memoryProvider;
+    this.filesDir = memoryFilesDir;
+    this.config = memoryConfig;
+  }
+  async list(req, res, query) {
+    const limit = Math.min(parseInt(query.limit) || 20, 100);
+    try {
+      send(res, 200, await this.provider.list(limit, query.offset || null));
+    } catch (err) {
+      send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message });
     }
-
-    handleAgentEvent(payload) {
-      const { runId, stream, data, sessionKey } = payload;
-      if (!runId) return;
-      if (!this.activityLogs.has(runId)) this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
-      const log = this.activityLogs.get(runId);
-      if (stream === 'assistant') {
-        const text = data?.text || '';
-        if (text) {
-          let currentSegment = log._currentAssistantSegment;
-          if (!currentSegment || currentSegment._sealed) {
-            currentSegment = { type: 'assistant', timestamp: Date.now(), text, _sealed: false };
-            log._currentAssistantSegment = currentSegment;
-            log.steps.push(currentSegment);
-          } else { currentSegment.text = text; }
-        }
+  }
+  async search(req, res, query) {
+    const q = (query.query || "").toLowerCase().trim();
+    if (!q) return send(res, 400, { error: "Missing query parameter" });
+    try {
+      send(res, 200, await this.provider.search(q));
+    } catch (err) {
+      send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message });
+    }
+  }
+  files(req, res, query) {
+    const q = (query.query || "").toLowerCase().trim();
+    const memories = this._parseFiles();
+    const filtered = q ? memories.filter((m) => m.data.toLowerCase().includes(q) || m.title.toLowerCase().includes(q)) : memories;
+    filtered.sort((a, b) => (b.createdAt || "").localeCompare(a.createdAt || ""));
+    send(res, 200, { memories: filtered });
+  }
+  _parseFiles() {
+    const memories = [];
+    const scanDir = /* @__PURE__ */ __name((dir, prefix = "") => {
+      let entries;
+      try {
+        entries = fs10.readdirSync(dir);
+      } catch {
         return;
       }
-      if (stream === 'thinking') {
-        const thinkingText = data?.text || '';
-        let thinkingStep = log.steps.find(s => s.type === 'thinking');
-        if (thinkingStep) { thinkingStep.text = thinkingText; }
-        else { log.steps.push({ type: 'thinking', timestamp: Date.now(), text: thinkingText }); }
-        this._writeActivityToDb(runId, log);
-        const now = Date.now();
-        if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
-          log._lastThinkingBroadcast = now;
-          this._broadcastActivityUpdate(runId, log);
+      for (const entry of entries) {
+        const fullPath = path11.join(dir, entry);
+        const stat = (() => {
+          try {
+            return fs10.statSync(fullPath);
+          } catch {
+            return null;
+          }
+        })();
+        if (!stat) continue;
+        if (stat.isDirectory() && !prefix) {
+          scanDir(fullPath, entry + "/");
+          continue;
         }
-      }
-      if (stream === 'tool') {
-        if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) { log._currentAssistantSegment._sealed = true; }
-        const _args = data?.args;
-        const _argsMeta = _args ? (_args.command || _args.path || _args.query || _args.url || Object.values(_args).find(v => typeof v === 'string') || '') : '';
-        const step = { type: 'tool', timestamp: Date.now(), name: data?.name || 'unknown', phase: data?.phase || 'start', toolCallId: data?.toolCallId, meta: data?.meta || (_argsMeta ? String(_argsMeta) : undefined), isError: data?.isError || false };
-        if (data?.phase === 'result') {
-          const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId && (s.phase === 'start' || s.phase === 'running'));
-          if (existing) { existing.phase = 'done'; existing.resultMeta = data?.meta; existing.isError = data?.isError || false; existing.durationMs = Date.now() - existing.timestamp; }
-          else { step.phase = 'done'; log.steps.push(step); }
-        } else if (data?.phase === 'update') {
-          const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId);
-          if (existing) { if (data?.meta) existing.resultMeta = data.meta; if (data?.isError) existing.isError = true; existing.phase = 'running'; }
-        } else { log.steps.push(step); }
-        this._writeActivityToDb(runId, log);
-        this._broadcastActivityUpdate(runId, log);
-      }
-      if (stream === 'lifecycle') {
-        if (data?.phase === 'end' || data?.phase === 'error') {
-          if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
-          const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant');
-          if (lastAssistantIdx >= 0) log.steps.splice(lastAssistantIdx, 1);
-          this._writeActivityToDb(runId, log);
-          this.activityLogs.delete(runId);
-          return;
+        if (!entry.endsWith(".md") || !stat.isFile()) continue;
+        const content = fs10.readFileSync(fullPath, "utf8");
+        const basename = entry.replace(/\.md$/, "");
+        const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})/);
+        if (prefix) {
+          memories.push({ id: `file:${prefix + basename}`, source: "file", file: prefix + basename, title: basename, data: content.trim(), createdAt: stat.mtime.toISOString() });
+        } else {
+          for (const section of content.split(/^(?=## )/m)) {
+            const trimmed = section.trim();
+            if (!trimmed) continue;
+            const headingMatch = trimmed.match(/^##\s+(.+)/);
+            const heading = headingMatch ? headingMatch[1].trim() : null;
+            const body = headingMatch ? trimmed.slice(trimmed.indexOf("\n") + 1).trim() : trimmed;
+            if (!heading && body.match(/^#\s+/) && body.split("\n").length <= 2) continue;
+            const title = heading || basename;
+            memories.push({ id: `file:${basename}:${title}`, source: "file", file: basename, title, data: heading ? `**${title}**
+${body}` : body, createdAt: dateMatch ? `${dateMatch[1]}T00:00:00Z` : stat.mtime.toISOString() });
+          }
         }
       }
+    }, "scanDir");
+    scanDir(this.filesDir);
+    return memories;
+  }
+  async update(req, res, params) {
+    try {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const { data } = JSON.parse(Buffer.concat(chunks).toString());
+      if (!(data || "").trim()) return send(res, 400, { error: "Missing data field" });
+      send(res, 200, { ok: true, result: await this.provider.update(params.id, data.trim()) });
+    } catch (err) {
+      send(res, 502, { error: "Failed to update memory", detail: err.message });
     }
-
-    _writeActivityToDb(runId, log) {
-      writeActivityToDb(_getDb, this.broadcastToBrowsers.bind(this), runId, log);
-    }
-
-    _broadcastActivityUpdate(runId, log) {
-      const parsed = log._parsed;
-      if (!parsed || !log._messageId) return;
-
-      const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
-
-      this.broadcastToBrowsers(JSON.stringify({
-        type: 'clawchats',
-        event: 'activity-updated',
-        workspace: parsed.workspace,
-        threadId: parsed.threadId,
-        messageId: log._messageId,
-        activityLog: cleanSteps,
-        activitySummary: this.generateActivitySummary(log.steps)
-      }));
-    }
-
-    generateActivitySummary(steps) {
-      return generateActivitySummary(steps);
+  }
+  async delete(req, res, params) {
+    try {
+      send(res, 200, { ok: true, result: await this.provider.delete(params.id) });
+    } catch (err) {
+      send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message });
     }
+  }
+  async status(req, res) {
+    const status = await this.provider.status();
+    send(res, 200, { provider: this.provider.name, host: this.config.host, port: this.config.port, collection: this.config.collection, backend: status, memoryFilesDir: this.filesDir, memoryFilesDirExists: fs10.existsSync(this.filesDir) });
+  }
+};
 
-    addBroadcastTarget(fn) { this._externalBroadcastTargets.push(fn); }
-    removeBroadcastTarget(fn) { this._externalBroadcastTargets = this._externalBroadcastTargets.filter(f => f !== fn); }
-
-    broadcastToBrowsers(data) {
-      _debugLogger.logFrame('SRV→BR', data);
-      for (const client of this.browserClients.keys()) {
-        if (client.readyState === WS.OPEN) client.send(data);
-      }
-      for (const fn of this._externalBroadcastTargets) {
-        try { fn(data); } catch { /* target disconnected */ }
+// server/controllers/filesystem.js
+import fs11 from "node:fs";
+import path12 from "node:path";
+import os3 from "node:os";
+var HOME2 = os3.homedir();
+var ALLOWED_FILE_DIRS = [HOME2, "/tmp"];
+function handleServeFile(req, res, query, memoryConfig) {
+  const filePath = query.path;
+  if (!filePath) return sendError(res, 400, "Missing path parameter");
+  const resolved = filePath.startsWith("./") || filePath.startsWith("../") ? path12.resolve(memoryConfig.workspaceDir, filePath) : path12.resolve(filePath);
+  if (!ALLOWED_FILE_DIRS.some((dir) => resolved.startsWith(dir + "/") || resolved === dir)) return sendError(res, 403, "Access denied: path not in allowed directories");
+  if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isFile()) return sendError(res, 404, "File not found");
+  const MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".csv": "text/csv",
+    ".xml": "text/xml",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "text/javascript",
+    ".py": "text/x-python",
+    ".sh": "text/x-shellscript",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".toml": "text/toml",
+    ".zip": "application/zip",
+    ".gz": "application/gzip",
+    ".tar": "application/x-tar",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm"
+  };
+  const stat = fs11.statSync(resolved);
+  res.writeHead(200, { "Content-Type": MIME[path12.extname(resolved).toLowerCase()] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*" });
+  fs11.createReadStream(resolved).pipe(res);
+}
+__name(handleServeFile, "handleServeFile");
+function handleWorkspaceList(req, res, query) {
+  const reqPath = query.path || "~/.openclaw/workspace";
+  const depth = parseInt(query.depth || "2", 10);
+  const showHidden = query.hidden === "1" || query.hidden === "true";
+  const resolved = path12.resolve(reqPath.replace(/^~/, HOME2));
+  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
+  if (!fs11.existsSync(resolved)) return sendError(res, 404, "Path not found");
+  const files = [{ path: resolved + "/", type: "dir", name: path12.basename(resolved), size: 0 }];
+  const walk = /* @__PURE__ */ __name((dir, d) => {
+    if (d > depth) return;
+    try {
+      for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") && entry.name !== ".openclaw" && !showHidden) continue;
+        if (entry.name === "node_modules") continue;
+        const fullPath = path12.join(dir, entry.name);
+        const isDir = entry.isDirectory();
+        files.push({ path: fullPath + (isDir ? "/" : ""), type: isDir ? "dir" : "file", name: entry.name, size: isDir ? 0 : (() => {
+          try {
+            return fs11.statSync(fullPath).size;
+          } catch {
+            return 0;
+          }
+        })() });
+        if (isDir) walk(fullPath, d + 1);
       }
+    } catch {
     }
-
-    broadcastGatewayStatus(connected) {
-      this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'gateway-status', connected }));
+  }, "walk");
+  walk(resolved, 1);
+  send(res, 200, { files, cwd: resolved });
+}
+__name(handleWorkspaceList, "handleWorkspaceList");
+function handleWorkspaceFileRead(req, res, query) {
+  const filePath = query.path;
+  if (!filePath) return sendError(res, 400, "Missing path parameter");
+  const resolved = path12.resolve(filePath.replace(/^~/, HOME2));
+  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
+  if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isFile()) return sendError(res, 404, "File not found");
+  const stat = fs11.statSync(resolved);
+  const ext = path12.extname(resolved).toLowerCase().slice(1);
+  const binaryMime = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", svg: "image/svg+xml", bmp: "image/bmp", ico: "image/x-icon", pdf: "application/pdf", mp3: "audio/mpeg", mp4: "video/mp4", wav: "audio/wav", ogg: "audio/ogg", webm: "video/webm" };
+  const mime = binaryMime[ext];
+  if (mime) {
+    if (stat.size > 20 * 1024 * 1024) return sendError(res, 413, "File too large (max 20MB)");
+    res.writeHead(200, { "Content-Type": mime, "Cache-Control": "private, max-age=60" });
+    res.end(fs11.readFileSync(resolved));
+  } else {
+    if (stat.size > 1024 * 1024) return sendError(res, 413, "File too large (max 1MB)");
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(fs11.readFileSync(resolved, "utf8"));
+  }
+}
+__name(handleWorkspaceFileRead, "handleWorkspaceFileRead");
+async function handleWorkspaceFileWrite(req, res, query) {
+  const filePath = query.path;
+  if (!filePath) return sendError(res, 400, "Missing path parameter");
+  const resolved = path12.resolve(filePath.replace(/^~/, HOME2));
+  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Can only write to workspace directory");
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  const dir = path12.dirname(resolved);
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(resolved, Buffer.concat(chunks).toString("utf8"), "utf8");
+  send(res, 200, { ok: true });
+}
+__name(handleWorkspaceFileWrite, "handleWorkspaceFileWrite");
+function handleWorkspaceFileDelete(req, res, query) {
+  const filePath = query.path;
+  if (!filePath) return sendError(res, 400, "Missing path parameter");
+  const resolved = path12.resolve(filePath.replace(/^~/, HOME2));
+  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
+  if (!fs11.existsSync(resolved)) return sendError(res, 404, "Path not found");
+  try {
+    const stat = fs11.statSync(resolved);
+    if (stat.isDirectory()) {
+      fs11.rmSync(resolved, { recursive: true, force: true });
+      send(res, 200, { ok: true, type: "dir" });
+    } else {
+      fs11.unlinkSync(resolved);
+      send(res, 200, { ok: true, type: "file" });
     }
+  } catch (err) {
+    sendError(res, 500, "Delete failed: " + err.message);
+  }
+}
+__name(handleWorkspaceFileDelete, "handleWorkspaceFileDelete");
+async function handleWorkspaceUpload(req, res, query) {
+  const targetDir = query.path;
+  if (!targetDir) return sendError(res, 400, "Missing path parameter");
+  const resolved = path12.resolve(targetDir.replace(/^~/, HOME2));
+  if (!resolved.startsWith(HOME2)) return sendError(res, 403, "Access denied");
+  if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isDirectory()) return sendError(res, 404, "Target directory not found");
+  if (!(req.headers["content-type"] || "").includes("multipart/form-data")) return sendError(res, 400, "Expected multipart/form-data");
+  let files;
+  try {
+    files = await parseMultipart(req);
+  } catch (err) {
+    return sendError(res, 400, "Invalid multipart data: " + err.message);
+  }
+  const uploaded = [];
+  for (const { filename, data } of files) {
+    if (!filename || !data.length) continue;
+    const safeName = path12.basename(filename);
+    let finalPath = path12.join(resolved, safeName);
+    let counter = 1;
+    while (fs11.existsSync(finalPath)) {
+      const ext = path12.extname(safeName);
+      finalPath = path12.join(resolved, `${path12.basename(safeName, ext)} (${counter++})${ext}`);
+    }
+    fs11.writeFileSync(finalPath, data);
+    uploaded.push({ name: path12.basename(finalPath), size: data.length });
+  }
+  send(res, 200, { ok: true, uploaded });
+}
+__name(handleWorkspaceUpload, "handleWorkspaceUpload");
 
-    sendToGateway(data) {
-      _debugLogger.logFrame('SRV→GW', data);
-      if (this.ws && this.ws.readyState === WS.OPEN) this.ws.send(data);
-      else console.error('Cannot send to gateway: not connected');
+// server/controllers/transcribe.js
+import fs12 from "node:fs";
+import path13 from "node:path";
+import os4 from "node:os";
+async function handleTranscribe(req, res) {
+  try {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    const audioBuffer = Buffer.concat(chunks);
+    if (audioBuffer.length === 0) return send(res, 400, { error: "No audio data" });
+    if (audioBuffer.length > 25 * 1024 * 1024) return send(res, 400, { error: "Audio too large (max 25MB)" });
+    let apiKey;
+    try {
+      const ocConfig = JSON.parse(fs12.readFileSync(path13.join(os4.homedir(), ".openclaw", "openclaw.json"), "utf8"));
+      apiKey = ocConfig?.skills?.entries?.["openai-whisper-api"]?.apiKey;
+    } catch {
     }
-
-    scheduleReconnect() {
-      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
-      this.reconnectAttempts++;
-      console.log(`Reconnecting to gateway in ${delay}ms (attempt ${this.reconnectAttempts})...`);
-      setTimeout(() => this.connect(), delay);
+    if (!apiKey) apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) return send(res, 500, { error: "No OpenAI API key configured" });
+    const contentType = req.headers["content-type"] || "audio/webm";
+    const ext = contentType.includes("wav") ? "wav" : contentType.includes("mp4") || contentType.includes("m4a") ? "m4a" : contentType.includes("ogg") ? "ogg" : "webm";
+    const boundary = "----WhisperBoundary" + Date.now();
+    const body = Buffer.concat([
+      `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="audio.${ext}"\r
+Content-Type: ${contentType}\r
+\r
+`,
+      audioBuffer,
+      `\r
+--${boundary}\r
+Content-Disposition: form-data; name="model"\r
+\r
+whisper-1\r
+`,
+      `--${boundary}\r
+Content-Disposition: form-data; name="response_format"\r
+\r
+json\r
+`,
+      `--${boundary}--\r
+`
+    ].map((p) => typeof p === "string" ? Buffer.from(p) : p));
+    const resp = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+      method: "POST",
+      headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": `multipart/form-data; boundary=${boundary}` },
+      body
+    });
+    if (!resp.ok) {
+      console.error("Whisper API error:", resp.status, await resp.text());
+      return send(res, 502, { error: `Whisper API error: ${resp.status}` });
     }
-
-    addBrowserClient(ws) {
-      this.browserClients.set(ws, { activeWorkspace: null, activeThreadId: null });
-      if (ws.readyState === WS.OPEN) {
-        ws.send(JSON.stringify({ type: 'clawchats', event: 'gateway-status', connected: this.connected }));
-        const streams = [];
-        for (const [sessionKey, state] of this.streamState.entries()) {
-          // Skip sessions in sentinel-hold state — their buffer contains a NO_REPLY/HEARTBEAT_OK
-          // prefix that should not be forwarded to reconnecting browsers.
-          if (state.state === 'streaming' && !(state.held?.length > 0)) {
-            streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
-          }
-        }
-        if (streams.length > 0) ws.send(JSON.stringify({ type: 'clawchats', event: 'stream-sync', streams }));
+    const result = await resp.json();
+    return send(res, 200, { text: result.text || "" });
+  } catch (err) {
+    console.error("Transcribe error:", err);
+    return send(res, 500, { error: err.message });
+  }
+}
+__name(handleTranscribe, "handleTranscribe");
+
+// server/index.js
+var HOME3 = os5.homedir();
+var PORT = parseInt(process.env.PORT || "3001", 10);
+var __dirname2 = path14.dirname(fileURLToPath2(import.meta.url));
+var PLUGIN_DIR = path14.resolve(__dirname2, "..");
+function createApp(config = {}) {
+  const DATA_DIR = config.dataDir || path14.join(PLUGIN_DIR, "data");
+  const UPLOADS_DIR = config.uploadsDir || path14.join(PLUGIN_DIR, "uploads");
+  const WORKSPACES_FILE = path14.join(DATA_DIR, "workspaces.json");
+  const SETTINGS_FILE = path14.join(DATA_DIR, "settings.json");
+  const INTELLIGENCE_DIR = path14.join(DATA_DIR, "intelligence");
+  const authToken = config.authToken !== void 0 ? config.authToken : AUTH_TOKEN;
+  const gatewayToken = config.gatewayToken !== void 0 ? config.gatewayToken : authToken;
+  const gatewayUrl = config.gatewayUrl || GATEWAY_WS_URL;
+  fs13.mkdirSync(DATA_DIR, { recursive: true });
+  fs13.mkdirSync(UPLOADS_DIR, { recursive: true });
+  const dbCache = /* @__PURE__ */ new Map();
+  function getDb(workspaceName) {
+    if (dbCache.has(workspaceName)) return dbCache.get(workspaceName);
+    const db = new Database(path14.join(DATA_DIR, `${workspaceName}.db`));
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    migrate(db);
+    dbCache.set(workspaceName, db);
+    return db;
+  }
+  __name(getDb, "getDb");
+  function getActiveDb() {
+    return requestDbStore.getStore() || getDb(getWorkspaces().active);
+  }
+  __name(getActiveDb, "getActiveDb");
+  function closeDb(name) {
+    const db = dbCache.get(name);
+    if (db) {
+      db.close();
+      dbCache.delete(name);
+    }
+  }
+  __name(closeDb, "closeDb");
+  function closeAll() {
+    for (const db of dbCache.values()) db.close();
+    dbCache.clear();
+    globalDbCache.close?.();
+  }
+  __name(closeAll, "closeAll");
+  let _globalDb = null;
+  const globalDbCache = {
+    get() {
+      if (_globalDb) return _globalDb;
+      _globalDb = new Database(path14.join(DATA_DIR, "global.db"));
+      _globalDb.exec("PRAGMA journal_mode = WAL");
+      _globalDb.exec(`CREATE TABLE IF NOT EXISTS custom_emojis (name TEXT NOT NULL, pack TEXT NOT NULL DEFAULT 'slackmojis', url TEXT NOT NULL, mime_type TEXT, created_at INTEGER DEFAULT (strftime('%s','now')), PRIMARY KEY (name, pack))`);
+      return _globalDb;
+    },
+    close() {
+      if (_globalDb) {
+        _globalDb.close();
+        _globalDb = null;
       }
     }
-
-    removeBrowserClient(ws) { this.browserClients.delete(ws); }
-
-    setActiveThread(ws, workspace, threadId) {
-      const client = ws ? this.browserClients.get(ws) : null;
-      if (client) { client.activeWorkspace = workspace; client.activeThreadId = threadId; }
-      if (workspace && threadId) {
-        try {
-          const wsData = _getWorkspaces();
-          if (!wsData.workspaces[workspace]) return;
-          const db = _getDb(workspace);
-          const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(threadId);
-          if (!thread) return;
-          const deleted = db.prepare('DELETE FROM unread_messages WHERE thread_id = ?').run(threadId);
-          if (deleted.changes > 0) {
-            syncThreadUnreadCount(db, threadId);
-            const workspaceUnreadTotal = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
-            this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'unread-update', workspace, threadId, action: 'clear', unreadCount: 0, workspaceUnreadTotal, timestamp: Date.now() }));
-          }
-        } catch (e) { console.error('Failed to auto-clear unreads on active-thread:', e.message); }
+  };
+  let workspacesConfig = null;
+  function getWorkspaces() {
+    if (!workspacesConfig) {
+      try {
+        workspacesConfig = JSON.parse(fs13.readFileSync(WORKSPACES_FILE, "utf8"));
+      } catch {
+        workspacesConfig = { active: "default", workspaces: { default: { name: "default", label: "Default", createdAt: Date.now() } } };
+        fs13.writeFileSync(WORKSPACES_FILE, JSON.stringify(workspacesConfig, null, 2));
       }
     }
-  }
-
-  const _gatewayClient = new _GatewayClient();
-
-  const _broadcast = (msg) => _gatewayClient.broadcastToBrowsers(msg);
-
-  function _handleGetSettings(req, res) {
+    return workspacesConfig;
+  }
+  __name(getWorkspaces, "getWorkspaces");
+  function setWorkspaces(data) {
+    workspacesConfig = data;
+    fs13.writeFileSync(WORKSPACES_FILE, JSON.stringify(data, null, 2));
+  }
+  __name(setWorkspaces, "setWorkspaces");
+  const debugLogger = new DebugLogger(DATA_DIR);
+  const mediaStash = /* @__PURE__ */ new Map();
+  const memoryConfig = discoverMemoryConfig();
+  const memoryProvider = createMemoryProvider(memoryConfig);
+  memoryProvider.init().catch((err) => console.error("[createApp] Memory provider init error:", err.message));
+  const MEMORY_FILES_DIR = path14.join(memoryConfig.workspaceDir, "memory");
+  const gatewayClient = new GatewayClient({ getDb, getWorkspaces, dataDir: DATA_DIR, debugLogger, gatewayWsUrl: gatewayUrl, authToken: gatewayToken, mediaStash });
+  const broadcast = /* @__PURE__ */ __name((msg) => gatewayClient.broadcastToBrowsers(msg), "broadcast");
+  const workspaces = new WorkspaceController({ getDb, closeDb, getWorkspaces, setWorkspaces, dataDir: DATA_DIR, broadcast });
+  const threads = new ThreadController({ getActiveDb, getWorkspaces, uploadsDir: UPLOADS_DIR, broadcast });
+  const messages = new MessageController({ getActiveDb, getWorkspaces, broadcast });
+  const files = new FileController({ getActiveDb, getWorkspaces, uploadsDir: UPLOADS_DIR, intelligenceDir: INTELLIGENCE_DIR });
+  const memory = new MemoryController({ memoryProvider, memoryFilesDir: MEMORY_FILES_DIR, memoryConfig });
+  function handleGetSettings(req, res) {
     try {
-      const data = fs.existsSync(_SETTINGS_FILE) ? JSON.parse(fs.readFileSync(_SETTINGS_FILE, 'utf8')) : {};
-      return send(res, 200, data);
-    } catch { return send(res, 200, {}); }
+      send(res, 200, fs13.existsSync(SETTINGS_FILE) ? JSON.parse(fs13.readFileSync(SETTINGS_FILE, "utf8")) : {});
+    } catch {
+      send(res, 200, {});
+    }
   }
-
-  async function _handleSaveSettings(req, res) {
+  __name(handleGetSettings, "handleGetSettings");
+  async function handleSaveSettings(req, res) {
     const body = await parseBody(req);
-    fs.mkdirSync(path.dirname(_SETTINGS_FILE), { recursive: true });
-    fs.writeFileSync(_SETTINGS_FILE, JSON.stringify(body, null, 2));
-    return send(res, 200, { ok: true });
+    fs13.mkdirSync(path14.dirname(SETTINGS_FILE), { recursive: true });
+    fs13.writeFileSync(SETTINGS_FILE, JSON.stringify(body, null, 2));
+    send(res, 200, { ok: true });
   }
-
-  const workspaces = new WorkspaceController({ getDb: _getDb, closeDb: _closeDb, getWorkspaces: _getWorkspaces, setWorkspaces: _setWorkspaces, dataDir: _DATA_DIR, broadcast: _broadcast });
-  const threads    = new ThreadController({ getActiveDb: _getActiveDb, getWorkspaces: _getWorkspaces, uploadsDir: _UPLOADS_DIR, broadcast: _broadcast });
-  const messages   = new MessageController({ getActiveDb: _getActiveDb, getWorkspaces: _getWorkspaces, broadcast: _broadcast });
-  const files      = new FileController({ getActiveDb: _getActiveDb, getWorkspaces: _getWorkspaces, uploadsDir: _UPLOADS_DIR, intelligenceDir: _INTELLIGENCE_DIR });
-  const memory     = new MemoryController({ memoryProvider: _memoryProvider, memoryFilesDir: _MEMORY_FILES_DIR, memoryConfig: _MEMORY_CONFIG });
-
-  // ── handleRequest (scoped to factory state) ────────────────────────────────
-  async function _handleRequest(req, res) {
-    const _wsName = req.headers?.['x-workspace'];
-    const _requestDb = _wsName ? _getDb(_wsName) : _getActiveDb();
-    return _requestDbStore.run(_requestDb, () => _handleRequestImplFactory(req, res));
+  __name(handleSaveSettings, "handleSaveSettings");
+  function checkAuth(req, res) {
+    if (!authToken) return true;
+    const auth = req.headers.authorization;
+    if (!auth?.startsWith("Bearer ")) {
+      sendError(res, 401, "Missing or invalid Authorization header");
+      return false;
+    }
+    if (auth.slice(7) !== authToken) {
+      sendError(res, 401, "Invalid auth token");
+      return false;
+    }
+    return true;
   }
-
-  async function _handleRequestImplFactory(req, res) {
-    const [urlPath, queryString] = (req.url || '/').split('?');
+  __name(checkAuth, "checkAuth");
+  async function handleRequest(req, res) {
+    const wsName = req.headers?.["x-workspace"];
+    const db = wsName ? getDb(wsName) : getActiveDb();
+    return requestDbStore.run(db, () => route(req, res));
+  }
+  __name(handleRequest, "handleRequest");
+  async function route(req, res) {
+    const [urlPath, queryString] = (req.url || "/").split("?");
     const query = {};
-    if (queryString) {
-      for (const pair of queryString.split('&')) {
-        const [k, v] = pair.split('=');
-        if (k) query[decodeURIComponent(k)] = decodeURIComponent(v || '');
-      }
+    if (queryString) for (const pair of queryString.split("&")) {
+      const [k, v] = pair.split("=");
+      if (k) query[decodeURIComponent(k)] = decodeURIComponent(v || "");
     }
     const method = req.method;
-
-    if (method === 'OPTIONS') { setCors(res); res.writeHead(204); return res.end(); }
-
-    if (method === 'GET' && !urlPath.startsWith('/api/')) {
-      const STATIC_FILES = { '/': 'index.html', '/index.html': 'index.html', '/app.js': 'app.js', '/style.css': 'style.css', '/error-handler.js': 'error-handler.js', '/manifest.json': 'manifest.json', '/favicon.ico': 'favicon.ico' };
-      const fileName = STATIC_FILES[urlPath];
-      const isIcon = urlPath.startsWith('/icons/');
-      const isLib = urlPath.startsWith('/lib/');
-      const isFrontend = urlPath.startsWith('/frontend/');
-      const isEmoji = urlPath.startsWith('/emoji/');
-      const isConfig = urlPath === '/config.js';
-      const staticPath = fileName ? path.join(__dirname, fileName) : (isIcon || isLib || isFrontend || isEmoji || isConfig) ? path.join(__dirname, urlPath.slice(1)) : null;
-      if (staticPath && fs.existsSync(staticPath) && fs.statSync(staticPath).isFile()) {
-        const ext = path.extname(staticPath).toLowerCase();
-        const mimeMap = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.ico': 'image/x-icon', '.png': 'image/png', '.svg': 'image/svg+xml', '.gif': 'image/gif', '.webp': 'image/webp' };
-        const ct = mimeMap[ext] || 'application/octet-stream';
-        const stat = fs.statSync(staticPath);
-        res.writeHead(200, { 'Content-Type': ct, 'Content-Length': stat.size, 'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=3600' });
-        return fs.createReadStream(staticPath).pipe(res);
+    let p;
+    if (method === "OPTIONS") {
+      setCors(res);
+      res.writeHead(204);
+      return res.end();
+    }
+    if (method === "GET" && !urlPath.startsWith("/api/")) {
+      const STATIC = { "/": "index.html", "/index.html": "index.html", "/app.js": "app.js", "/style.css": "style.css", "/error-handler.js": "error-handler.js", "/manifest.json": "manifest.json", "/favicon.ico": "favicon.ico" };
+      const fileName = STATIC[urlPath];
+      const isAllowed = fileName || urlPath.startsWith("/icons/") || urlPath.startsWith("/lib/") || urlPath.startsWith("/frontend/") || urlPath.startsWith("/emoji/") || urlPath === "/config.js";
+      if (isAllowed) {
+        const staticPath = path14.join(PLUGIN_DIR, fileName || urlPath.slice(1));
+        if (fs13.existsSync(staticPath) && fs13.statSync(staticPath).isFile()) {
+          const MIME = { ".html": "text/html", ".js": "text/javascript", ".css": "text/css", ".json": "application/json", ".ico": "image/x-icon", ".png": "image/png", ".svg": "image/svg+xml", ".gif": "image/gif", ".webp": "image/webp" };
+          const ext = path14.extname(staticPath).toLowerCase();
+          const stat = fs13.statSync(staticPath);
+          res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream", "Content-Length": stat.size, "Cache-Control": ext === ".html" ? "no-cache" : "public, max-age=3600" });
+          return fs13.createReadStream(staticPath).pipe(res);
+        }
       }
     }
-
-    let p;
-    if ((p = matchRoute(method, urlPath, 'GET /api/uploads/:threadId/:fileId'))) return files.serveUpload(req, res, p);
-
-    // Custom emoji listing (no auth)
-    if (method === 'GET' && urlPath === '/api/emoji') {
+    if (p = matchRoute(method, urlPath, "GET /api/uploads/:threadId/:fileId")) return files.serveUpload(req, res, p);
+    if (method === "GET" && urlPath === "/api/emoji") {
       try {
-        const db = getGlobalDb(_DATA_DIR);
-        const rows = db.prepare('SELECT name, pack, url, mime_type FROM custom_emojis ORDER BY created_at DESC').all();
-        res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=300' });
+        const rows = globalDbCache.get().prepare("SELECT name, pack, url, mime_type FROM custom_emojis ORDER BY created_at DESC").all();
+        res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "public, max-age=300" });
         return res.end(JSON.stringify(rows));
-      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ error: e.message }));
+      }
     }
-
-    // Search slackmojis.com (no auth, proxied)
-    if (method === 'GET' && urlPath === '/api/emoji/search') {
-      const q = query.q || '';
-      if (!q) { res.writeHead(400, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: 'Missing ?q=' })); }
+    if (method === "GET" && urlPath === "/api/emoji/search") {
+      const q = query.q || "";
+      if (!q) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ error: "Missing ?q=" }));
+      }
       try {
-        const https = await import('https');
+        const https = await import("https");
         const html = await new Promise((resolve, reject) => {
           https.default.get(`https://slackmojis.com/emojis/search?query=${encodeURIComponent(q)}`, (resp) => {
-            let body = ''; resp.on('data', c => body += c); resp.on('end', () => resolve(body));
-          }).on('error', reject);
+            let body = "";
+            resp.on("data", (c) => body += c);
+            resp.on("end", () => resolve(body));
+          }).on("error", reject);
         });
         const results = [];
         const regex = /data-emoji-id-name="([^"]+)"[^>]*href="([^"]+)"[\s\S]*?<img[^>]*src="([^"]+)"/g;
         let match;
-        while ((match = regex.exec(html)) !== null && results.length < 50) {
-          const name = match[1].replace(/^\d+-/, '');
-          results.push({ name, image_url: match[3], download_url: `https://slackmojis.com${match[2]}` });
-        }
-        res.writeHead(200, { 'Content-Type': 'application/json' });
+        while ((match = regex.exec(html)) !== null && results.length < 50) results.push({ name: match[1].replace(/^\d+-/, ""), image_url: match[3], download_url: `https://slackmojis.com${match[2]}` });
+        res.writeHead(200, { "Content-Type": "application/json" });
         return res.end(JSON.stringify(results));
-      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ error: e.message }));
+      }
     }
-
-    if (!_checkAuth(req, res)) return;
-
-    // Add custom emoji (auth required)
-    if (method === 'POST' && urlPath === '/api/emoji/add') {
-      try {
+    if (!checkAuth(req, res)) return;
+    try {
+      if (method === "POST" && urlPath === "/api/emoji/add") {
         const { url, name, pack } = await parseBody(req);
-        if (!url || !name) { res.writeHead(400, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: 'Missing url or name' })); }
-        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
-        const targetPack = pack || 'slackmojis';
-        const urlLower = url.split('?')[0].toLowerCase();
-        let mimeType = 'image/png';
-        if (urlLower.endsWith('.gif')) mimeType = 'image/gif';
-        else if (urlLower.endsWith('.webp')) mimeType = 'image/webp';
-        else if (urlLower.endsWith('.jpg') || urlLower.endsWith('.jpeg')) mimeType = 'image/jpeg';
-        const db = getGlobalDb(_DATA_DIR);
-        db.prepare('INSERT OR REPLACE INTO custom_emojis (name, pack, url, mime_type) VALUES (?, ?, ?, ?)').run(safeName, targetPack, url, mimeType);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
+        if (!url || !name) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          return res.end(JSON.stringify({ error: "Missing url or name" }));
+        }
+        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+        const targetPack = pack || "slackmojis";
+        const mimeType = url.toLowerCase().endsWith(".gif") ? "image/gif" : url.toLowerCase().endsWith(".webp") ? "image/webp" : url.toLowerCase().match(/\.jpe?g/) ? "image/jpeg" : "image/png";
+        globalDbCache.get().prepare("INSERT OR REPLACE INTO custom_emojis (name, pack, url, mime_type) VALUES (?, ?, ?, ?)").run(safeName, targetPack, url, mimeType);
+        res.writeHead(200, { "Content-Type": "application/json" });
         return res.end(JSON.stringify({ name: safeName, pack: targetPack, url, mime_type: mimeType }));
-      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
-    }
-
-    // Delete custom emoji (auth required)
-    if (method === 'DELETE' && urlPath === '/api/emoji') {
-      try {
+      }
+      if (method === "DELETE" && urlPath === "/api/emoji") {
         const { name, pack } = await parseBody(req);
-        if (!name || !pack) { res.writeHead(400, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: 'Missing name or pack' })); }
-        const db = getGlobalDb(_DATA_DIR);
-        db.prepare('DELETE FROM custom_emojis WHERE name = ? AND pack = ?').run(name, pack);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
+        if (!name || !pack) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          return res.end(JSON.stringify({ error: "Missing name or pack" }));
+        }
+        globalDbCache.get().prepare("DELETE FROM custom_emojis WHERE name = ? AND pack = ?").run(name, pack);
+        res.writeHead(200, { "Content-Type": "application/json" });
         return res.end(JSON.stringify({ ok: true }));
-      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
-    }
-
-    try {
-      if (method === 'GET' && urlPath === '/api/file') return handleServeFile(req, res, query);
-      if (method === 'GET' && urlPath === '/api/workspace') return handleWorkspaceList(req, res, query);
-      if (method === 'GET' && urlPath === '/api/workspace/file') return handleWorkspaceFileRead(req, res, query);
-      if (method === 'PUT' && urlPath === '/api/workspace/file') return await handleWorkspaceFileWrite(req, res, query);
-      if (method === 'DELETE' && urlPath === '/api/workspace/file') return handleWorkspaceFileDelete(req, res, query);
-      if (method === 'POST' && urlPath === '/api/workspace/upload') return await handleWorkspaceUpload(req, res, query);
-      if (method === 'GET' && urlPath === '/api/memory/status') return await memory.status(req, res);
-      if (method === 'GET' && urlPath === '/api/memory/list') return await memory.list(req, res, query);
-      if (method === 'GET' && urlPath === '/api/memory/search') return await memory.search(req, res, query);
-      if (method === 'GET' && urlPath === '/api/memory/files') return memory.files(req, res, query);
-      if ((p = matchRoute(method, urlPath, 'PUT /api/memory/:id'))) return await memory.update(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/memory/:id'))) return await memory.delete(req, res, p);
-      if (method === 'GET' && urlPath === '/api/settings') return _handleGetSettings(req, res);
-      if (method === 'PUT' && urlPath === '/api/settings') return await _handleSaveSettings(req, res);
-      if (method === 'POST' && urlPath === '/api/transcribe') return await handleTranscribe(req, res);
-      if (method === 'GET' && urlPath === '/api/agents') {
+      }
+      if (method === "GET" && urlPath === "/api/file") return handleServeFile(req, res, query, memoryConfig);
+      if (method === "GET" && urlPath === "/api/workspace") return handleWorkspaceList(req, res, query);
+      if (method === "GET" && urlPath === "/api/workspace/file") return handleWorkspaceFileRead(req, res, query);
+      if (method === "PUT" && urlPath === "/api/workspace/file") return await handleWorkspaceFileWrite(req, res, query);
+      if (method === "DELETE" && urlPath === "/api/workspace/file") return handleWorkspaceFileDelete(req, res, query);
+      if (method === "POST" && urlPath === "/api/workspace/upload") return await handleWorkspaceUpload(req, res, query);
+      if (method === "GET" && urlPath === "/api/memory/status") return await memory.status(req, res);
+      if (method === "GET" && urlPath === "/api/memory/list") return await memory.list(req, res, query);
+      if (method === "GET" && urlPath === "/api/memory/search") return await memory.search(req, res, query);
+      if (method === "GET" && urlPath === "/api/memory/files") return memory.files(req, res, query);
+      if (p = matchRoute(method, urlPath, "PUT /api/memory/:id")) return await memory.update(req, res, p);
+      if (p = matchRoute(method, urlPath, "DELETE /api/memory/:id")) return await memory.delete(req, res, p);
+      if (method === "GET" && urlPath === "/api/settings") return handleGetSettings(req, res);
+      if (method === "PUT" && urlPath === "/api/settings") return await handleSaveSettings(req, res);
+      if (method === "POST" && urlPath === "/api/transcribe") return await handleTranscribe(req, res);
+      if (method === "GET" && urlPath === "/api/health") return send(res, 200, { ok: true, workspace: getWorkspaces().active, uptime: process.uptime() });
+      if (method === "GET" && urlPath === "/api/agents") {
         try {
-          const agentsDir = path.join(HOME, '.openclaw', 'agents');
-          const agents = fs.readdirSync(agentsDir, { withFileTypes: true })
-            .filter(e => e.isDirectory()).map(e => e.name);
-          return send(res, 200, { agents });
-        } catch { return send(res, 200, { agents: ['main'] }); }
+          send(res, 200, { agents: fs13.readdirSync(path14.join(HOME3, ".openclaw", "agents"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) });
+        } catch {
+          send(res, 200, { agents: ["main"] });
+        }
+        return;
       }
-      if (method === 'GET' && urlPath === '/api/workspaces') return workspaces.getAll(req, res);
-      if (method === 'POST' && urlPath === '/api/workspaces') return await workspaces.create(req, res);
-      if ((p = matchRoute(method, urlPath, 'PATCH /api/workspaces/:name'))) return await workspaces.update(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/workspaces/:name'))) return workspaces.delete(req, res, p);
-      if (method === 'POST' && urlPath === '/api/workspaces/reorder') return await workspaces.reorder(req, res);
-      if ((p = matchRoute(method, urlPath, 'POST /api/workspaces/:name/activate'))) return workspaces.activate(req, res, p);
-      if (method === 'GET' && urlPath === '/api/threads') return threads.getAll(req, res, {}, query);
-      if (method === 'GET' && urlPath === '/api/threads/unread') return threads.getUnread(req, res);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/mark-read'))) return await threads.markRead(req, res, p);
-      if (method === 'POST' && urlPath === '/api/threads') return await threads.create(req, res);
-      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/messages'))) return messages.getAll(req, res, p, query);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/messages'))) return await messages.create(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id/messages/:messageId'))) return messages.delete(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/context-fill'))) return messages.contextFill(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/generate-title'))) {
-        const db = _getActiveDb();
-        const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(p.id);
-        if (!thread) return sendError(res, 404, 'Thread not found');
-        // Regenerate: sets heuristic immediately (safe fallback), then fires AI upgrade
-        const activeWs = _getWorkspaces().active;
-        _gatewayClient.generateThreadTitle(db, p.id, activeWs);
+      if (method === "GET" && urlPath === "/api/workspaces") return workspaces.getAll(req, res);
+      if (method === "POST" && urlPath === "/api/workspaces") return await workspaces.create(req, res);
+      if (p = matchRoute(method, urlPath, "PATCH /api/workspaces/:name")) return await workspaces.update(req, res, p);
+      if (p = matchRoute(method, urlPath, "DELETE /api/workspaces/:name")) return workspaces.delete(req, res, p);
+      if (method === "POST" && urlPath === "/api/workspaces/reorder") return await workspaces.reorder(req, res);
+      if (p = matchRoute(method, urlPath, "POST /api/workspaces/:name/activate")) return workspaces.activate(req, res, p);
+      if (method === "GET" && urlPath === "/api/threads") return threads.getAll(req, res, {}, query);
+      if (method === "GET" && urlPath === "/api/threads/unread") return threads.getUnread(req, res);
+      if (method === "POST" && urlPath === "/api/threads") return await threads.create(req, res);
+      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/mark-read")) return await threads.markRead(req, res, p);
+      if (p = matchRoute(method, urlPath, "GET /api/threads/:id/messages")) return messages.getAll(req, res, p, query);
+      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/messages")) return await messages.create(req, res, p);
+      if (p = matchRoute(method, urlPath, "DELETE /api/threads/:id/messages/:messageId")) return messages.delete(req, res, p);
+      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/context-fill")) return messages.contextFill(req, res, p);
+      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/generate-title")) {
+        const db = getActiveDb();
+        const thread = db.prepare("SELECT * FROM threads WHERE id = ?").get(p.id);
+        if (!thread) return sendError(res, 404, "Thread not found");
+        gatewayClient.generateThreadTitle(db, p.id, getWorkspaces().active);
         return send(res, 200, { ok: true });
       }
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/upload'))) return await files.upload(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/intelligence'))) return files.getIntelligence(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/intelligence'))) return await files.saveIntelligence(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id'))) return threads.get(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'PATCH /api/threads/:id'))) return await threads.update(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id'))) return threads.delete(req, res, p);
-      if (method === 'GET' && urlPath === '/api/search') return messages.search(req, res, {}, query);
-      if (method === 'GET' && urlPath === '/api/export') return messages.export(req, res);
-      if (method === 'POST' && urlPath === '/api/import') return await messages.import(req, res);
-      if (method === 'POST' && urlPath === '/api/active-thread') {
+      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/upload")) return await files.upload(req, res, p);
+      if (p = matchRoute(method, urlPath, "GET /api/threads/:id/intelligence")) return files.getIntelligence(req, res, p);
+      if (p = matchRoute(method, urlPath, "POST /api/threads/:id/intelligence")) return await files.saveIntelligence(req, res, p);
+      if (p = matchRoute(method, urlPath, "GET /api/threads/:id")) return threads.get(req, res, p);
+      if (p = matchRoute(method, urlPath, "PATCH /api/threads/:id")) return await threads.update(req, res, p);
+      if (p = matchRoute(method, urlPath, "DELETE /api/threads/:id")) return threads.delete(req, res, p);
+      if (method === "GET" && urlPath === "/api/search") return messages.search(req, res, {}, query);
+      if (method === "GET" && urlPath === "/api/export") return messages.export(req, res);
+      if (method === "POST" && urlPath === "/api/import") return await messages.import(req, res);
+      if (method === "POST" && urlPath === "/api/active-thread") {
         const body = await parseBody(req);
-        const { threadId, workspace } = body;
-        if (threadId && workspace) _gatewayClient.setActiveThread(null, workspace, threadId);
+        if (body.threadId && body.workspace) gatewayClient.setActiveThread(null, body.workspace, body.threadId);
         return send(res, 200, { ok: true });
       }
-      if (method === 'GET' && urlPath === '/api/health') return send(res, 200, { ok: true, workspace: _getWorkspaces().active, uptime: process.uptime() });
       sendError(res, 404, `Not found: ${method} ${urlPath}`);
     } catch (err) {
       console.error(`Error handling ${method} ${urlPath}:`, err);
-      if (err.message && err.message.includes('UNIQUE constraint')) sendError(res, 409, 'Conflict: ' + err.message);
-      else sendError(res, 500, err.message || 'Internal server error');
+      if (err.message?.includes("UNIQUE constraint")) sendError(res, 409, "Conflict: " + err.message);
+      else sendError(res, 500, err.message || "Internal server error");
     }
   }
-
-  // ── Browser WebSocket setup (shared logic for standalone and plugin) ────────
-  function _setupBrowserWs(wssInstance) {
-    wssInstance.on('connection', (ws) => {
-      console.log('Browser client connected');
-      _gatewayClient.addBrowserClient(ws);
-      const nonce = crypto.randomUUID();
-      ws.send(JSON.stringify({ type: 'event', event: 'connect.challenge', payload: { nonce, ts: Date.now() } }));
-
-      ws.on('message', (data) => {
+  __name(route, "route");
+  function setupBrowserWs(wss) {
+    wss.on("connection", (ws) => {
+      console.log("Browser client connected");
+      gatewayClient.addBrowserClient(ws);
+      ws.send(JSON.stringify({ type: "event", event: "connect.challenge", payload: { nonce: uuid(), ts: Date.now() } }));
+      ws.on("message", async (data) => {
         const msgStr = data.toString();
-        _debugLogger.logFrame('BR→SRV', msgStr);
+        debugLogger.logFrame("BR\u2192SRV", msgStr);
         let msgToForward = msgStr;
         try {
           const msg = JSON.parse(msgStr);
-          if (msg.type === 'req' && msg.method === 'connect') {
+          if (msg.type === "req" && msg.method === "connect") {
             const token = msg.params?.auth?.token;
-            if (token === _AUTH_TOKEN || !_AUTH_TOKEN) {
-              console.log('Browser client authenticated');
-              ws.send(JSON.stringify({ type: 'res', id: msg.id, ok: true, payload: { type: 'hello-ok', protocol: 3, server: { version: '0.1.0', host: 'clawchats-backend' } } }));
+            if (token === authToken || !authToken) {
+              ws.send(JSON.stringify({ type: "res", id: msg.id, ok: true, payload: { type: "hello-ok", protocol: 3, server: { version: "0.1.0", host: "clawchats-backend" } } }));
             } else {
-              console.log('Browser client auth failed');
-              ws.send(JSON.stringify({ type: 'res', id: msg.id, ok: false, error: { code: 'AUTH_FAILED', message: 'Invalid auth token' } }));
+              ws.send(JSON.stringify({ type: "res", id: msg.id, ok: false, error: { code: "AUTH_FAILED", message: "Invalid auth token" } }));
               ws.close();
             }
             return;
           }
-          if (msg.type === 'clawchats' || msg.type === 'shellchat') { // backward compat: accept legacy 'shellchat' type
-            if (msg.action === 'active-thread') { _gatewayClient.setActiveThread(ws, msg.workspace, msg.threadId); console.log(`Browser client set active thread: ${msg.workspace}/${msg.threadId}`); return; }
-            if (msg.action === 'debug-start') { const result = _debugLogger.start(msg.ts, ws); if (result.error === 'already-active') ws.send(JSON.stringify({ type: 'clawchats', event: 'debug-error', error: 'Recording already active in another tab', sessionId: result.sessionId })); else ws.send(JSON.stringify({ type: 'clawchats', event: 'debug-started', sessionId: result.sessionId })); return; }
-            if (msg.action === 'debug-dump') { const { sessionId, files } = _debugLogger.saveDump(msg); ws.send(JSON.stringify({ type: 'clawchats', event: 'debug-saved', sessionId, files })); return; }
+          if (msg.type === "clawchats" || msg.type === "shellchat") {
+            if (msg.action === "active-thread") {
+              gatewayClient.setActiveThread(ws, msg.workspace, msg.threadId);
+              return;
+            }
+            if (msg.action === "debug-start") {
+              const r = debugLogger.start(msg.ts, ws);
+              ws.send(JSON.stringify(r.error === "already-active" ? { type: "clawchats", event: "debug-error", error: "Recording already active in another tab", sessionId: r.sessionId } : { type: "clawchats", event: "debug-started", sessionId: r.sessionId }));
+              return;
+            }
+            if (msg.action === "debug-dump") {
+              const r = debugLogger.saveDump(msg);
+              ws.send(JSON.stringify({ type: "clawchats", event: "debug-saved", sessionId: r.sessionId, files: r.files }));
+              return;
+            }
           }
-          // Save inline attachments to disk so the agent can access them as file paths
-          if (msg.type === 'req' && msg.method === 'chat.send' && msg.params?.attachments?.length > 0) {
-            const parsed = parseSessionKey(msg.params.sessionKey || '');
-            const threadId = parsed?.threadId || 'misc';
-            const uploadDir = path.join(_UPLOADS_DIR, threadId);
-            fs.mkdirSync(uploadDir, { recursive: true });
-            const extMap = { jpeg: 'jpg', jpg: 'jpg', png: 'png', gif: 'gif', webp: 'webp', pdf: 'pdf', 'svg+xml': 'svg', mp3: 'mp3', mp4: 'mp4', wav: 'wav', webm: 'webm' };
+          if (msg.type === "req" && msg.method === "chat.send" && msg.params?.attachments?.length > 0) {
+            const parsed = parseSessionKey(msg.params.sessionKey || "");
+            const threadId = parsed?.threadId || "misc";
+            const uploadDir = path14.join(UPLOADS_DIR, threadId);
+            fs13.mkdirSync(uploadDir, { recursive: true });
+            const extMap = { jpeg: "jpg", jpg: "jpg", png: "png", gif: "gif", webp: "webp", pdf: "pdf", "svg+xml": "svg", mp3: "mp3", mp4: "mp4", wav: "wav", webm: "webm" };
             const savedPaths = [];
             for (const att of msg.params.attachments) {
               if (!att.content || !att.mimeType) continue;
               try {
-                const rawExt = att.mimeType.split('/')[1]?.split(';')[0] || 'bin';
-                const ext = extMap[rawExt] || rawExt;
-                const fileId = `${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-                const filePath = path.join(uploadDir, `${fileId}.${ext}`);
-                fs.writeFileSync(filePath, Buffer.from(att.content, 'base64'));
+                const rawExt = att.mimeType.split("/")[1]?.split(";")[0] || "bin";
+                const filePath = path14.join(uploadDir, `${Date.now()}_${Math.random().toString(36).slice(2, 6)}.${extMap[rawExt] || rawExt}`);
+                fs13.writeFileSync(filePath, Buffer.from(att.content, "base64"));
                 savedPaths.push(filePath);
-                console.log(`[upload] Saved attachment to ${filePath}`);
               } catch (err) {
-                console.error('[upload] Failed to save attachment:', err.message);
+                console.error("[upload] Failed to save attachment:", err.message);
               }
             }
             if (savedPaths.length > 0) {
-              const label = savedPaths.length === 1 ? 'Attached file saved on disk' : 'Attached files saved on disk';
-              const note = `\n\n[${label}:\n${savedPaths.map(p => `- ${p}`).join('\n')}]`;
-              msgToForward = JSON.stringify({ ...msg, params: { ...msg.params, message: (msg.params.message || '') + note } });
+              const note = `
+
+[${savedPaths.length === 1 ? "Attached file saved on disk" : "Attached files saved on disk"}:
+${savedPaths.map((p) => `- ${p}`).join("\n")}]`;
+              msgToForward = JSON.stringify({ ...msg, params: { ...msg.params, message: (msg.params.message || "") + note } });
             }
           }
-        } catch { /* Not JSON or not a ClawChats message, forward as-is */ }
-        _gatewayClient.sendToGateway(msgToForward);
+        } catch {
+        }
+        gatewayClient.sendToGateway(msgToForward);
       });
-
-      ws.on('close', () => { console.log('Browser client disconnected'); _debugLogger.handleClientDisconnect(ws); _gatewayClient.removeBrowserClient(ws); });
-      ws.on('error', (err) => { console.error('Browser WebSocket error:', err.message); });
+      ws.on("close", () => {
+        console.log("Browser client disconnected");
+        debugLogger.handleClientDisconnect(ws);
+        gatewayClient.removeBrowserClient(ws);
+      });
+      ws.on("error", (err) => console.error("Browser WebSocket error:", err.message));
     });
   }
-
-  // ── Public API ─────────────────────────────────────────────────────────────
-  _ensureDirs();
-
+  __name(setupBrowserWs, "setupBrowserWs");
   return {
-    handleRequest: _handleRequest,
-    getDb: _getDb,
-    getActiveDb: _getActiveDb,
-    migrate,
-    getWorkspaces: _getWorkspaces,
-    setWorkspaces: _setWorkspaces,
-    shutdown: _closeAllDbs,
-    closeAllDbs: _closeAllDbs,
-    gatewayClient: _gatewayClient,
-    setupBrowserWs: _setupBrowserWs,
-    dataDir: _DATA_DIR,
+    handleRequest,
+    getDb,
+    getActiveDb,
+    getWorkspaces,
+    setWorkspaces,
+    shutdown: closeAll,
+    closeAllDbs: closeAll,
+    gatewayClient,
+    setupBrowserWs,
+    dataDir: DATA_DIR
   };
 }
-
-// ─── Server Startup (standalone mode only) ───────────────────────────────────
-
-const isDirectRun = import.meta.url === `file://${process.argv[1]}`;
+__name(createApp, "createApp");
+function migrate(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS threads (
+      id TEXT PRIMARY KEY, session_key TEXT UNIQUE NOT NULL, title TEXT DEFAULT 'New chat',
+      pinned INTEGER DEFAULT 0, pin_order INTEGER DEFAULT 0, model TEXT,
+      last_session_id TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL,
+      status TEXT DEFAULT 'sent', metadata TEXT, seq INTEGER, timestamp INTEGER NOT NULL, created_at INTEGER NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages(thread_id, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_messages_dedup ON messages(thread_id, role, timestamp);
+  `);
+  try {
+    db.exec("ALTER TABLE threads ADD COLUMN sort_order INTEGER DEFAULT 0");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE threads ADD COLUMN unread_count INTEGER DEFAULT 0");
+  } catch {
+  }
+  db.exec(`CREATE TABLE IF NOT EXISTS unread_messages (thread_id TEXT NOT NULL, message_id TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY (thread_id, message_id), FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE)`);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_unread_thread ON unread_messages(thread_id)");
+  ensureFts(db);
+}
+__name(migrate, "migrate");
+function createFts(db) {
+  db.exec(`CREATE VIRTUAL TABLE messages_fts USING fts5(content, content=messages, content_rowid=rowid, tokenize='porter unicode61 tokenchars x27')`);
+  db.exec(`CREATE TRIGGER messages_ai AFTER INSERT ON messages BEGIN INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content); END`);
+  db.exec(`CREATE TRIGGER messages_ad AFTER DELETE ON messages BEGIN INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content); END`);
+  db.exec(`CREATE TRIGGER messages_au AFTER UPDATE ON messages BEGIN INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content); INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content); END`);
+}
+__name(createFts, "createFts");
+function dropFts(db) {
+  db.exec("DROP TABLE IF EXISTS messages_fts; DROP TRIGGER IF EXISTS messages_ai; DROP TRIGGER IF EXISTS messages_ad; DROP TRIGGER IF EXISTS messages_au;");
+}
+__name(dropFts, "dropFts");
+function ensureFts(db) {
+  const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
+  if (!hasFts) {
+    try {
+      createFts(db);
+      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
+    } catch (e) {
+      console.error("[DB] messages_fts creation failed:", e.message);
+    }
+    return;
+  }
+  const schema = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
+  if (schema && !schema.sql.includes("tokenchars")) {
+    console.log("[DB] Upgrading messages_fts tokenizer...");
+    try {
+      dropFts(db);
+      createFts(db);
+      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
+      console.log("[DB] Upgrade complete");
+    } catch (e) {
+      console.error("[DB] Upgrade failed:", e.message);
+      dropFts(db);
+    }
+  } else {
+    try {
+      db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('integrity-check')").run();
+    } catch {
+      try {
+        db.prepare("INSERT INTO messages_fts(messages_fts) VALUES('rebuild')").run();
+      } catch (e) {
+        console.error("[DB] FTS rebuild failed:", e.message);
+        dropFts(db);
+      }
+    }
+  }
+}
+__name(ensureFts, "ensureFts");
+var isDirectRun = import.meta.url === `file://${process.argv[1]}`;
 if (isDirectRun) {
   const app = createApp();
-  app.getActiveDb(); // Eagerly open active workspace DB
-
+  app.getActiveDb();
   const server = http.createServer(app.handleRequest);
-
-  // ─── Browser WebSocket Server ───────────────────────────────────────────────
-
   const wss = new WebSocketServer({ noServer: true });
   app.setupBrowserWs(wss);
-
-  // Handle WebSocket upgrade requests
-  server.on('upgrade', (req, socket, head) => {
-    wss.handleUpgrade(req, socket, head, (ws) => {
-      wss.emit('connection', ws, req);
-    });
+  server.on("upgrade", (req, socket, head) => {
+    wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
   });
-
   server.listen(PORT, () => {
     console.log(`ClawChats backend listening on port ${PORT}`);
     console.log(`Active workspace: ${app.getWorkspaces().active}`);
     console.log(`Data dir: ${app.dataDir}`);
-
-    // Connect to gateway
     app.gatewayClient.connect();
-
-    // Initialize global DB (custom emojis, etc.)
-    getGlobalDb(DATA_DIR);
   });
-
-  // Graceful shutdown
-  function shutdown() {
-    console.log('Shutting down...');
+  const shutdown = /* @__PURE__ */ __name(() => {
+    console.log("Shutting down...");
     app.shutdown();
     server.close(() => process.exit(0));
-    // Force exit after 5s
-    setTimeout(() => process.exit(1), 5000);
-  }
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
-}
+    setTimeout(() => process.exit(1), 5e3);
+  }, "shutdown");
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+export {
+  createApp
+};