@knowsuchagency/fulcrum 2.7.1 → 2.8.2

package/drizzle/0052_agent_memory.sql

@@ -0,0 +1,27 @@
+CREATE TABLE `memories` (
+	`id` text PRIMARY KEY NOT NULL,
+	`content` text NOT NULL,
+	`tags` text,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL
+);--> statement-breakpoint
+CREATE VIRTUAL TABLE `memories_fts` USING fts5(
+	content,
+	tags,
+	content=memories,
+	content_rowid=rowid
+);--> statement-breakpoint
+CREATE TRIGGER memories_ai AFTER INSERT ON `memories` BEGIN
+	INSERT INTO memories_fts(rowid, content, tags)
+	VALUES (new.rowid, new.content, new.tags);
+END;--> statement-breakpoint
+CREATE TRIGGER memories_ad AFTER DELETE ON `memories` BEGIN
+	INSERT INTO memories_fts(memories_fts, rowid, content, tags)
+	VALUES ('delete', old.rowid, old.content, old.tags);
+END;--> statement-breakpoint
+CREATE TRIGGER memories_au AFTER UPDATE ON `memories` BEGIN
+	INSERT INTO memories_fts(memories_fts, rowid, content, tags)
+	VALUES ('delete', old.rowid, old.content, old.tags);
+	INSERT INTO memories_fts(rowid, content, tags)
+	VALUES (new.rowid, new.content, new.tags);
+END;

package/drizzle/0053_add_memory_source.sql

@@ -0,0 +1 @@
+ALTER TABLE `memories` ADD `source` text;

package/drizzle/meta/_journal.json

@@ -365,6 +365,20 @@
       "when": 1770548000000,
       "tag": "0051_caldav_tables",
       "breakpoints": true
+    },
+    {
+      "idx": 52,
+      "version": "6",
+      "when": 1770634400000,
+      "tag": "0052_agent_memory",
+      "breakpoints": true
+    },
+    {
+      "idx": 53,
+      "version": "6",
+      "when": 1770720800000,
+      "tag": "0053_add_memory_source",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowsuchagency/fulcrum",
-  "version": "2.7.1",
+  "version": "2.8.2",
   "description": "Harness Attention. Orchestrate Agents. Ship.",
   "license": "PolyForm-Perimeter-1.0.0",
   "repository": {

package/server/index.js

@@ -4368,6 +4368,7 @@ __export(exports_schema, {
   projectAttachments: () => projectAttachments,
   messagingSessionMappings: () => messagingSessionMappings,
   messagingConnections: () => messagingConnections,
+  memories: () => memories,
   emailAuthorizedThreads: () => emailAuthorizedThreads,
   deployments: () => deployments,
   chatSessions: () => chatSessions,
@@ -4380,7 +4381,7 @@ __export(exports_schema, {
   appServices: () => appServices,
   actionableEvents: () => actionableEvents
 });
-var tasks, taskRelationships, taskDependencies, taskLinks, taskAttachments, projectLinks, projectAttachments, terminalTabs, terminals, terminalViewState, repositories, apps, appServices, deployments, tunnels, projects, projectRepositories, tags, taskTags, projectTags, chatSessions, chatMessages, artifacts, systemMetrics, messagingConnections, messagingSessionMappings, emailAuthorizedThreads, channelMessages, actionableEvents, sweepRuns, caldavCalendars, caldavEvents;
+var tasks, taskRelationships, taskDependencies, taskLinks, taskAttachments, projectLinks, projectAttachments, terminalTabs, terminals, terminalViewState, repositories, apps, appServices, deployments, tunnels, projects, projectRepositories, tags, taskTags, projectTags, chatSessions, chatMessages, artifacts, systemMetrics, messagingConnections, messagingSessionMappings, emailAuthorizedThreads, channelMessages, actionableEvents, sweepRuns, caldavCalendars, caldavEvents, memories;
 var init_schema = __esm(() => {
   init_sqlite_core();
   tasks = sqliteTable("tasks", {
@@ -4747,6 +4748,14 @@ var init_schema = __esm(() => {
     createdAt: text("created_at").notNull(),
     updatedAt: text("updated_at").notNull()
   });
+  memories = sqliteTable("memories", {
+    id: text("id").primaryKey(),
+    content: text("content").notNull(),
+    tags: text("tags"),
+    source: text("source"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  });
 });
 
 // server/lib/settings/types.ts
@@ -70943,7 +70952,13 @@ function getDataModel() {
 - Calendars with display name, color, sync state
 - Events with summary, start/end times, location, all-day flag
 - Timezone-aware storage and display
-- Used to give the assistant schedule awareness for planning`;
+- Used to give the assistant schedule awareness for planning
+
+**Memories** - Persistent agent knowledge store
+- Content with optional tags for categorization
+- SQLite FTS5 full-text search (boolean operators, phrase matching, prefix queries)
+- Used to remember facts, preferences, decisions, and patterns across conversations
+- Browsable via Monitoring > Memory tab in the UI`;
 }
 function getMcpToolCapabilities() {
   return `## Available MCP Tools
@@ -71021,6 +71036,10 @@ You have access to Fulcrum's MCP tools. Use them proactively to help users.
 - \`get_assistant_stats\` - Get event counts and last sweep times
 - \`get_last_sweep\` - Check when last sweep ran
 
+**Memory Tools:**
+- \`memory_store\` - Store a piece of knowledge in persistent memory with optional tags
+- \`memory_search\` - Search memories using FTS5 full-text search (supports AND, OR, NOT, "phrases", prefix*)
+
 **Utilities:**
 - \`list_tags\` - See all tags in use
 - \`get_task_dependency_graph\` - Visualize task dependencies
@@ -71205,6 +71224,7 @@ You can read and modify all Fulcrum settings using the settings MCP tools. Setti
 - \`assistant.model\` - Model tier: 'opus', 'sonnet', 'haiku'
 - \`assistant.customInstructions\` - Custom system prompt additions
 - \`assistant.documentsDir\` - Directory for assistant documents
+- \`assistant.observerModel\` - Model for observe-only messages (non-self WhatsApp, unauthorized emails), e.g., 'haiku' for cost savings
 - \`assistant.ritualsEnabled\` - Enable/disable daily rituals (morning/evening briefings)
 - \`assistant.morningRitual.time\` - Time for morning ritual (24h format, e.g., "09:00")
 - \`assistant.morningRitual.prompt\` - Custom prompt for morning ritual
@@ -71322,12 +71342,14 @@ Fulcrum is your digital concierge - a personal command center where you track ev
 - Deploying apps with Docker Compose
 - Sending notifications to Slack, Discord, Pushover
 - Calendar awareness via CalDAV sync (Google Calendar, etc.)
+- Persistent memory across conversations (store and search knowledge)
 
 **Key tools available:**
 - list_tasks, create_task, update_task, move_task
 - list_projects, create_project
 - execute_command (run any CLI command)
 - send_notification
+- memory_store, memory_search (persistent knowledge across sessions)
 - message (send to email/WhatsApp - concierge mode)
 - create_actionable_event, list_actionable_events (track decisions - concierge mode)
 
@@ -463771,7 +463793,8 @@ var ToolCategorySchema = exports_external.enum([
   "email",
   "messaging",
   "assistant",
-  "caldav"
+  "caldav",
+  "memory"
 ]);
 var AgentTypeSchema = exports_external.enum(["claude", "opencode"]);
 
@@ -464538,6 +464561,20 @@ var toolRegistry = [
     category: "caldav",
     keywords: ["calendar", "event", "delete", "remove", "cancel"],
     defer_loading: true
+  },
+  {
+    name: "memory_store",
+    description: "Store a piece of knowledge in persistent memory",
+    category: "memory",
+    keywords: ["memory", "store", "save", "remember", "knowledge", "persist", "fact"],
+    defer_loading: false
+  },
+  {
+    name: "memory_search",
+    description: "Search persistent memory using full-text search",
+    category: "memory",
+    keywords: ["memory", "search", "find", "recall", "knowledge", "retrieve", "remember"],
+    defer_loading: false
   }
 ];
 function searchTools(query) {
@@ -466103,6 +466140,44 @@ var registerCaldavTools = (server, client) => {
   });
 };
 
+// shared/types.ts
+var MEMORY_SOURCES = [
+  "channel:whatsapp",
+  "channel:slack",
+  "channel:discord",
+  "channel:telegram",
+  "channel:email",
+  "conversation:assistant"
+];
+
+// cli/src/mcp/tools/memory.ts
+var registerMemoryTools = (server, client) => {
+  server.tool("memory_store", "Store a piece of knowledge in persistent memory. Use this to remember facts, preferences, decisions, patterns, or any information that should persist across conversations.", {
+    content: exports_external.string().describe("The memory content to store. Be specific and self-contained."),
+    tags: exports_external.optional(exports_external.array(exports_external.string())).describe('Optional tags for categorization (e.g., ["preference", "architecture", "decision"])'),
+    source: exports_external.optional(exports_external.enum(MEMORY_SOURCES)).describe('Where this memory originated (e.g., "channel:whatsapp", "conversation:assistant")')
+  }, async ({ content, tags: tags2, source }) => {
+    try {
+      const result = await client.storeMemory({ content, tags: tags2, source });
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+  server.tool("memory_search", 'Search persistent memory using full-text search. Supports boolean operators (AND, OR, NOT), phrase matching ("quoted phrases"), and prefix matching (term*). Try different search terms or synonyms if initial results are insufficient.', {
+    query: exports_external.string().describe('FTS5 search query. Supports: AND, OR, NOT operators, "quoted phrases", prefix* matching. Example: "user preference" OR settings'),
+    tags: exports_external.optional(exports_external.array(exports_external.string())).describe("Optional tag filter - only return memories with at least one of these tags"),
+    limit: exports_external.optional(exports_external.number()).describe("Maximum results to return (default: 20)")
+  }, async ({ query, tags: tags2, limit: limit2 }) => {
+    try {
+      const results = await client.searchMemories({ query, tags: tags2, limit: limit2 });
+      return formatSuccess(results);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+};
+
 // cli/src/mcp/tools/index.ts
 function registerTools(server, client) {
   registerCoreTools(server, client);
@@ -466118,6 +466193,7 @@ function registerTools(server, client) {
   registerEmailTools(server, client);
   registerAssistantEventTools(server, client);
   registerCaldavTools(server, client);
+  registerMemoryTools(server, client);
 }
 // cli/src/utils/server.ts
 import { existsSync as existsSync27, readFileSync as readFileSync15, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, cpSync } from "fs";
@@ -466802,6 +466878,34 @@ class FulcrumClient {
       method: "DELETE"
     });
   }
+  async storeMemory(input) {
+    return this.fetch("/api/memory", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async searchMemories(input) {
+    const params = new URLSearchParams({ q: input.query });
+    if (input.tags?.length)
+      params.set("tags", input.tags.join(","));
+    if (input.limit)
+      params.set("limit", String(input.limit));
+    return this.fetch(`/api/memory/search?${params.toString()}`);
+  }
+  async listMemories(input) {
+    const params = new URLSearchParams;
+    if (input?.tags?.length)
+      params.set("tags", input.tags.join(","));
+    if (input?.limit)
+      params.set("limit", String(input.limit));
+    if (input?.offset)
+      params.set("offset", String(input.offset));
+    const query = params.toString();
+    return this.fetch(`/api/memory${query ? `?${query}` : ""}`);
+  }
+  async deleteMemory(id) {
+    return this.fetch(`/api/memory/${id}`, { method: "DELETE" });
+  }
   async getAssistantStats() {
     return this.fetch("/api/assistant/stats");
   }
@@ -466818,7 +466922,7 @@ mcpRoutes.all("/", async (c) => {
   });
   const server = new McpServer({
     name: "fulcrum",
-    version: "2.7.1"
+    version: "2.8.2"
   });
   const client = new FulcrumClient(`http://localhost:${port}`);
   registerTools(server, client);
@@ -472623,6 +472727,195 @@ caldavRoutes.delete("/events/:id", async (c) => {
 });
 var caldav_default = caldavRoutes;
 
+// server/services/memory-service.ts
+init_db2();
+init_schema();
+init_drizzle_orm();
+init_nanoid();
+function parseTags(tagsJson) {
+  if (!tagsJson)
+    return null;
+  try {
+    return JSON.parse(tagsJson);
+  } catch {
+    return null;
+  }
+}
+function toResult(row, rank) {
+  return {
+    id: row.id,
+    content: row.content,
+    tags: parseTags(row.tags),
+    source: row.source,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    ...rank !== undefined ? { rank } : {}
+  };
+}
+async function storeMemory(input) {
+  const now = new Date().toISOString();
+  const id = nanoid();
+  const tagsJson = input.tags?.length ? JSON.stringify(input.tags) : null;
+  const [row] = await db2.insert(memories).values({
+    id,
+    content: input.content,
+    tags: tagsJson,
+    source: input.source ?? null,
+    createdAt: now,
+    updatedAt: now
+  }).returning();
+  return toResult(row);
+}
+async function searchMemories(input) {
+  const limit2 = input.limit ?? 20;
+  const ftsQuery = input.query;
+  if (input.tags?.length) {
+    const results2 = db2.all(sql`SELECT m.id, m.content, m.tags, m.source, m.created_at as "createdAt", m.updated_at as "updatedAt", bm25(memories_fts) as rank
+          FROM memories_fts fts
+          JOIN memories m ON m.rowid = fts.rowid
+          WHERE memories_fts MATCH ${ftsQuery}
+            AND EXISTS (
+              SELECT 1 FROM json_each(m.tags) je
+              WHERE je.value IN ${input.tags}
+            )
+          ORDER BY bm25(memories_fts)
+          LIMIT ${limit2}`);
+    return results2.map((r) => ({
+      ...r,
+      tags: parseTags(r.tags)
+    }));
+  }
+  const results = db2.all(sql`SELECT m.id, m.content, m.tags, m.source, m.created_at as "createdAt", m.updated_at as "updatedAt", bm25(memories_fts) as rank
+        FROM memories_fts fts
+        JOIN memories m ON m.rowid = fts.rowid
+        WHERE memories_fts MATCH ${ftsQuery}
+        ORDER BY bm25(memories_fts)
+        LIMIT ${limit2}`);
+  return results.map((r) => ({
+    ...r,
+    tags: parseTags(r.tags)
+  }));
+}
+async function updateMemory(id, input) {
+  const now = new Date().toISOString();
+  const updates = { updatedAt: now };
+  if (input.content !== undefined)
+    updates.content = input.content;
+  if (input.tags !== undefined)
+    updates.tags = input.tags?.length ? JSON.stringify(input.tags) : null;
+  const [row] = await db2.update(memories).set({
+    ...input.content !== undefined ? { content: input.content } : {},
+    ...input.tags !== undefined ? { tags: input.tags?.length ? JSON.stringify(input.tags) : null } : {},
+    ...input.source !== undefined ? { source: input.source } : {},
+    updatedAt: now
+  }).where(eq(memories.id, id)).returning();
+  if (!row)
+    return null;
+  return toResult(row);
+}
+async function deleteMemory(id) {
+  const result = await db2.delete(memories).where(eq(memories.id, id)).returning();
+  return result.length > 0;
+}
+async function listMemories(input = {}) {
+  const limit2 = input.limit ?? 50;
+  const offset = input.offset ?? 0;
+  if (input.tags?.length) {
+    const rows2 = db2.all(sql`SELECT m.id, m.content, m.tags, m.source, m.created_at as "createdAt", m.updated_at as "updatedAt"
+          FROM memories m
+          WHERE EXISTS (
+            SELECT 1 FROM json_each(m.tags) je
+            WHERE je.value IN ${input.tags}
+          )
+          ORDER BY m.created_at DESC
+          LIMIT ${limit2} OFFSET ${offset}`);
+    const [countResult2] = db2.all(sql`SELECT COUNT(*) as count FROM memories m
+          WHERE EXISTS (
+            SELECT 1 FROM json_each(m.tags) je
+            WHERE je.value IN ${input.tags}
+          )`);
+    return {
+      memories: rows2.map((r) => ({
+        ...r,
+        tags: parseTags(r.tags)
+      })),
+      total: countResult2.count
+    };
+  }
+  const rows = await db2.select().from(memories).orderBy(desc(memories.createdAt)).limit(limit2).offset(offset);
+  const [countResult] = db2.all(sql`SELECT COUNT(*) as count FROM memories`);
+  return {
+    memories: rows.map((r) => toResult(r)),
+    total: countResult.count
+  };
+}
+
+// server/routes/memory.ts
+var app25 = new Hono2;
+app25.post("/", async (c) => {
+  const body = await c.req.json();
+  if (!body.content?.trim()) {
+    return c.json({ error: "content is required" }, 400);
+  }
+  const memory = await storeMemory({
+    content: body.content.trim(),
+    tags: body.tags,
+    source: body.source
+  });
+  return c.json(memory, 201);
+});
+app25.get("/search", async (c) => {
+  const query2 = c.req.query("q");
+  if (!query2?.trim()) {
+    return c.json({ error: "q query parameter is required" }, 400);
+  }
+  const tagsParam = c.req.query("tags");
+  const tags2 = tagsParam ? tagsParam.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
+  const limitParam = c.req.query("limit");
+  const limit2 = limitParam ? parseInt(limitParam, 10) : undefined;
+  const results = await searchMemories({
+    query: query2.trim(),
+    tags: tags2,
+    limit: limit2
+  });
+  return c.json(results);
+});
+app25.get("/", async (c) => {
+  const tagsParam = c.req.query("tags");
+  const tags2 = tagsParam ? tagsParam.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
+  const limitParam = c.req.query("limit");
+  const limit2 = limitParam ? parseInt(limitParam, 10) : undefined;
+  const offsetParam = c.req.query("offset");
+  const offset = offsetParam ? parseInt(offsetParam, 10) : undefined;
+  const result = await listMemories({ tags: tags2, limit: limit2, offset });
+  return c.json(result);
+});
+app25.patch("/:id", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json();
+  if (body.content !== undefined && !body.content.trim()) {
+    return c.json({ error: "content cannot be empty" }, 400);
+  }
+  const updated = await updateMemory(id, {
+    content: body.content?.trim(),
+    tags: body.tags,
+    source: body.source
+  });
+  if (!updated) {
+    return c.json({ error: "Memory not found" }, 404);
+  }
+  return c.json(updated);
+});
+app25.delete("/:id", async (c) => {
+  const id = c.req.param("id");
+  const deleted = await deleteMemory(id);
+  if (!deleted) {
+    return c.json({ error: "Memory not found" }, 404);
+  }
+  return c.json({ success: true });
+});
+var memory_default = app25;
+
 // server/app.ts
 init_logger3();
 function getDistPath() {
@@ -472632,51 +472925,52 @@ function getDistPath() {
   return join40(process.cwd(), "dist");
 }
 function createApp() {
-  const app25 = new Hono2;
-  app25.use("*", logger());
-  app25.use("*", cors({
+  const app26 = new Hono2;
+  app26.use("*", logger());
+  app26.use("*", cors({
     origin: "*",
     allowMethods: ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"],
     allowHeaders: ["Content-Type", "mcp-session-id", "Last-Event-ID", "mcp-protocol-version"],
     exposeHeaders: ["mcp-session-id", "mcp-protocol-version"]
   }));
-  app25.route("/health", health_default);
-  app25.route("/api/tasks", tasks_default);
-  app25.route("/api/git", git_default);
-  app25.route("/api/fs", filesystem_default);
-  app25.route("/api/config", config_default);
-  app25.route("/api/uploads", uploads_default);
-  app25.route("/api/worktrees", worktrees_default);
-  app25.route("/api/terminal-view-state", terminal_view_state_default);
-  app25.route("/api/repositories", repositories_default);
-  app25.route("/api/copier", copier_default);
-  app25.route("/api/github", github_default);
-  app25.route("/api/monitoring", monitoringRoutes);
-  app25.route("/api/system", system_default);
-  app25.route("/api/exec", exec_default);
-  app25.route("/api/apps", apps_default);
-  app25.route("/api/compose", compose_default);
-  app25.route("/api/deployment", deployment_default);
-  app25.route("/api/jobs", jobs_default);
-  app25.route("/api/opencode", opencode_default);
-  app25.route("/api/projects", projects_default);
-  app25.route("/api/task-dependencies", task_dependencies_default);
-  app25.route("/api/tags", tags_default);
-  app25.route("/api/version", version_default);
-  app25.route("/mcp", mcp_default);
-  app25.route("/api/chat", chat_default);
-  app25.route("/api/assistant", assistant_default);
-  app25.route("/api/messaging", messaging_default);
-  app25.route("/api/backup", backup_default);
-  app25.route("/api/caldav", caldav_default);
-  app25.post("/api/logs", async (c) => {
+  app26.route("/health", health_default);
+  app26.route("/api/tasks", tasks_default);
+  app26.route("/api/git", git_default);
+  app26.route("/api/fs", filesystem_default);
+  app26.route("/api/config", config_default);
+  app26.route("/api/uploads", uploads_default);
+  app26.route("/api/worktrees", worktrees_default);
+  app26.route("/api/terminal-view-state", terminal_view_state_default);
+  app26.route("/api/repositories", repositories_default);
+  app26.route("/api/copier", copier_default);
+  app26.route("/api/github", github_default);
+  app26.route("/api/monitoring", monitoringRoutes);
+  app26.route("/api/system", system_default);
+  app26.route("/api/exec", exec_default);
+  app26.route("/api/apps", apps_default);
+  app26.route("/api/compose", compose_default);
+  app26.route("/api/deployment", deployment_default);
+  app26.route("/api/jobs", jobs_default);
+  app26.route("/api/opencode", opencode_default);
+  app26.route("/api/projects", projects_default);
+  app26.route("/api/task-dependencies", task_dependencies_default);
+  app26.route("/api/tags", tags_default);
+  app26.route("/api/version", version_default);
+  app26.route("/mcp", mcp_default);
+  app26.route("/api/chat", chat_default);
+  app26.route("/api/assistant", assistant_default);
+  app26.route("/api/messaging", messaging_default);
+  app26.route("/api/backup", backup_default);
+  app26.route("/api/caldav", caldav_default);
+  app26.route("/api/memory", memory_default);
+  app26.post("/api/logs", async (c) => {
     const { entries } = await c.req.json();
     for (const entry of entries) {
       writeEntry(entry);
     }
     return c.json({ ok: true });
   });
-  app25.post("/api/debug", async (c) => {
+  app26.post("/api/debug", async (c) => {
     const body = await c.req.json();
     const entry = {
       ts: new Date().toISOString(),
@@ -472717,14 +473011,14 @@ function createApp() {
         }
       });
     };
-    app25.get("/assets/*", async (c) => {
+    app26.get("/assets/*", async (c) => {
       const assetPath = join40(distPath, c.req.path);
       if (existsSync34(assetPath)) {
         return serveFile(assetPath, true);
       }
       return c.notFound();
     });
-    app25.get("/sounds/*", async (c) => {
+    app26.get("/sounds/*", async (c) => {
       const soundPath = join40(distPath, c.req.path);
       if (existsSync34(soundPath)) {
         return serveFile(soundPath);
@@ -472733,7 +473027,7 @@ function createApp() {
     });
     const staticFiles = ["fulcrum-icon.png", "fulcrum-logo.jpeg", "vite.svg", "logo.png", "goat.jpeg"];
     for (const file2 of staticFiles) {
-      app25.get(`/${file2}`, async () => {
+      app26.get(`/${file2}`, async () => {
         const filePath = join40(distPath, file2);
         if (existsSync34(filePath)) {
           return serveFile(filePath);
@@ -472741,7 +473035,7 @@ function createApp() {
         return new Response("Not Found", { status: 404 });
       });
     }
-    app25.get("*", async (c, next) => {
+    app26.get("*", async (c, next) => {
       const path15 = c.req.path;
       if (path15.startsWith("/api/") || path15.startsWith("/ws/") || path15 === "/health") {
         return next();
@@ -472752,7 +473046,7 @@ function createApp() {
       });
     });
   }
-  return app25;
+  return app26;
 }
 
 // server/index.ts
@@ -473109,11 +473403,11 @@ setBroadcastDestroyed((terminalId) => {
     payload: { terminalId }
   });
 });
-var app25 = createApp();
-var { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app25 });
-app25.get("/ws/terminal", upgradeWebSocket(() => terminalWebSocketHandlers));
+var app26 = createApp();
+var { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app26 });
+app26.get("/ws/terminal", upgradeWebSocket(() => terminalWebSocketHandlers));
 var server2 = serve({
-  fetch: app25.fetch,
+  fetch: app26.fetch,
   port: PORT,
   hostname: HOST
 }, (info) => {