@mgsoftwarebv/mcp-server-bridge 2.23.4 → 3.0.1

package/dist/index.js

@@ -2,45 +2,176 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, ListResourcesRequestSchema, CallToolRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { createClient } from '@supabase/supabase-js';
-import { createHash } from 'crypto';
 import { Octokit } from '@octokit/rest';
+import { createHash } from 'crypto';
+import { eq, or, ilike, and, desc, asc, inArray, sql } from 'drizzle-orm';
+import { createJobDb } from '@refront/db/job-client';
+import * as schema from '@refront/db/schema';
+import { createStorageClient } from '@refront/storage';
+
+var _client = null;
+function getClient() {
+  if (!_client) {
+    if (!process.env.DATABASE_PRIMARY_POOLER_URL) {
+      throw new Error(
+        "DATABASE_PRIMARY_POOLER_URL is not set. Pass --database-url=... or export the env var before starting the MCP bridge."
+      );
+    }
+    _client = createJobDb();
+  }
+  return _client;
+}
+var db = new Proxy({}, {
+  get(_target, prop) {
+    const real = getClient().db;
+    const value = Reflect.get(real, prop, real);
+    return typeof value === "function" ? value.bind(real) : value;
+  }
+});
+async function getAccessibleTeamIds(teamId) {
+  const rows = await db.select({ id: schema.teams.id }).from(schema.teams).where(
+    or(eq(schema.teams.id, teamId), eq(schema.teams.parentTeamId, teamId))
+  );
+  const ids = rows.map((r) => r.id);
+  return ids.length > 0 ? ids : [teamId];
+}
+async function getAccessibleProjectIds(userId, teamId) {
+  try {
+    const rows = await db.execute(
+      sql`SELECT project_id FROM get_accessible_project_ids(${userId}::uuid, ${teamId}::uuid)`
+    );
+    return rows.map((r) => r.project_id).filter(Boolean);
+  } catch (error) {
+    console.error("\u274C Error getting accessible project IDs:", error);
+    return [];
+  }
+}
+async function getAccessibleCustomerIds(teamId) {
+  const teamIds = await getAccessibleTeamIds(teamId);
+  const ownCustomers = await db.select({ id: schema.customers.id }).from(schema.customers).where(
+    teamIds.length === 1 ? eq(schema.customers.teamId, teamIds[0]) : sql`${schema.customers.teamId} = ANY(${teamIds}::uuid[])`
+  );
+  const sharedCustomers = await db.select({ customerId: schema.customerSharedTeams.customerId }).from(schema.customerSharedTeams).where(eq(schema.customerSharedTeams.teamId, teamId));
+  return [
+    .../* @__PURE__ */ new Set([
+      ...ownCustomers.map((c) => c.id),
+      ...sharedCustomers.map((c) => c.customerId)
+    ])
+  ];
+}
+async function resolveAiSessionId(prefix, teamIds) {
+  if (teamIds.length === 0) return null;
+  const rows = await db.select({ id: schema.aiSessions.id }).from(schema.aiSessions).where(
+    and(
+      teamIds.length === 1 ? eq(schema.aiSessions.teamId, teamIds[0]) : sql`${schema.aiSessions.teamId} = ANY(${teamIds}::uuid[])`,
+      sql`${schema.aiSessions.id}::text LIKE ${`${prefix}%`}`
+    )
+  ).limit(1);
+  return rows[0]?.id ?? null;
+}
+var _storage = null;
+function buildClient() {
+  const endpoint = process.env.R2_ENDPOINT;
+  const accessKeyId = process.env.R2_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.R2_SECRET_ACCESS_KEY;
+  if (!endpoint || !accessKeyId || !secretAccessKey) {
+    throw new Error(
+      "R2 storage is not configured. Set R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY."
+    );
+  }
+  return createStorageClient({
+    endpoint,
+    accessKeyId,
+    secretAccessKey,
+    publicDomain: process.env.R2_PUBLIC_DOMAIN || void 0,
+    publicBuckets: [
+      "vault",
+      "avatars",
+      "team-logos",
+      "blog-images",
+      "customer-assets"
+    ]
+  });
+}
+var storage = new Proxy({}, {
+  get(_target, prop) {
+    if (!_storage) _storage = buildClient();
+    return Reflect.get(_storage, prop, _storage);
+  }
+});
 
+// src/index.ts
 var args = process.argv.slice(2);
-var apiKey = args.find((arg) => arg.startsWith("--api-key="))?.split("=")[1] || process.env.MG_TICKETS_API_KEY;
-var supabaseUrl = args.find((arg) => arg.startsWith("--supabase-url="))?.split("=")[1] || process.env.SUPABASE_URL || "https://supabase.refront.nl";
-var supabaseKey = args.find((arg) => arg.startsWith("--supabase-key="))?.split("=")[1] || process.env.SUPABASE_SERVICE_ROLE_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoic2VydmljZV9yb2xlIiwiaXNzIjoic3VwYWJhc2UiLCJpYXQiOjE3NzIwMzE4MzUsImV4cCI6MTkyOTcxMTgzNX0.M0glA9Ry0v87f-WzLKjLfS2Or4141b8c6Czoj1m5fjE";
+function readArg(name) {
+  const prefix = `--${name}=`;
+  const hit = args.find((a) => a.startsWith(prefix));
+  return hit ? hit.slice(prefix.length) : void 0;
+}
+var apiKey = readArg("api-key") ?? process.env.MG_TICKETS_API_KEY;
+var databaseUrl = readArg("database-url") ?? process.env.DATABASE_PRIMARY_POOLER_URL ?? process.env.DATABASE_URL;
 if (!apiKey) {
-  console.error("\u274C API key is required. Use --api-key=your_key or set MG_TICKETS_API_KEY environment variable");
+  console.error(
+    "\u274C API key is required. Use --api-key=your_key or set MG_TICKETS_API_KEY environment variable"
+  );
   process.exit(1);
 }
-var supabase = createClient(supabaseUrl, supabaseKey);
+if (!databaseUrl) {
+  console.error(
+    "\u274C Database URL is required. Use --database-url=postgresql://... or set DATABASE_PRIMARY_POOLER_URL (or DATABASE_URL) environment variable."
+  );
+  process.exit(1);
+}
+process.env.DATABASE_PRIMARY_POOLER_URL = databaseUrl;
+function asToolArgs(input) {
+  return input ?? {};
+}
 function roundToNearest15Minutes(minutes) {
   if (minutes <= 0) return 0;
   return Math.round(minutes / 15) * 15;
 }
-async function getAccessibleTeamIds(teamId) {
-  const { data: accessibleTeams } = await supabase.from("teams").select("id").or(`id.eq.${teamId},parent_team_id.eq.${teamId}`);
-  return accessibleTeams?.map((t) => t.id) || [teamId];
+function isImageFile(mimeType) {
+  return mimeType.startsWith("image/") && ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"].includes(
+    mimeType
+  );
 }
-async function getAccessibleProjectIds(userId, teamId) {
-  const { data, error } = await supabase.rpc("get_accessible_project_ids", {
-    p_user_id: userId,
-    p_team_id: teamId
-  });
-  if (error) {
-    console.error("\u274C Error getting accessible project IDs:", error);
-    return [];
+async function downloadImageAsBase64(storageKey) {
+  try {
+    let signedUrl;
+    try {
+      const { url } = await storage.createSignedUrl({
+        bucket: "vault",
+        path: storageKey,
+        expiresIn: 3600
+      });
+      signedUrl = url;
+    } catch (err) {
+      console.error(`Failed to create signed URL for ${storageKey}:`, err);
+      return null;
+    }
+    const response = await fetch(signedUrl);
+    if (!response.ok) {
+      console.error(
+        `Failed to download file ${storageKey}: ${response.status}`
+      );
+      return null;
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer).toString("base64");
+  } catch (error) {
+    console.error(`Error downloading image ${storageKey}:`, error);
+    return null;
   }
-  return data?.map((row) => row.project_id) || [];
 }
-async function getAccessibleCustomerIds(teamId) {
-  const teamIds = await getAccessibleTeamIds(teamId);
-  const { data: ownCustomers } = await supabase.from("customers").select("id").in("team_id", teamIds);
-  const ownCustomerIds = ownCustomers?.map((c) => c.id) || [];
-  const { data: sharedCustomers } = await supabase.from("customer_shared_teams").select("customer_id").eq("team_id", teamId);
-  const sharedCustomerIds = sharedCustomers?.map((c) => c.customer_id) || [];
-  return [.../* @__PURE__ */ new Set([...ownCustomerIds, ...sharedCustomerIds])];
+function buildTicketAccessPredicate(teamIds, projectIds, customerIds) {
+  const branches = [];
+  if (teamIds.length > 0) branches.push(inArray(schema.tickets.teamId, teamIds));
+  if (projectIds.length > 0)
+    branches.push(inArray(schema.tickets.projectId, projectIds));
+  if (customerIds.length > 0)
+    branches.push(inArray(schema.tickets.customerId, customerIds));
+  if (branches.length === 0) return sql`false`;
+  if (branches.length === 1) return branches[0];
+  return or(...branches);
 }
 async function validateApiKey(key) {
   if (!key.startsWith("mid_") || key.length !== 68) {
@@ -50,17 +181,25 @@ async function validateApiKey(key) {
   try {
     const keyHash = createHash("sha256").update(key).digest("hex");
     console.error(`\u{1F50D} Validating API key hash: ${keyHash.substring(0, 16)}...`);
-    const { data: apiKeyData, error } = await supabase.from("api_keys").select("id, user_id, team_id, scopes, last_used_at").eq("key_hash", keyHash).single();
-    if (error || !apiKeyData) {
-      console.error("\u274C API key not found or invalid:", error?.message);
+    const [apiKeyData] = await db.select({
+      id: schema.apiKeys.id,
+      userId: schema.apiKeys.userId,
+      teamId: schema.apiKeys.teamId,
+      scopes: schema.apiKeys.scopes,
+      lastUsedAt: schema.apiKeys.lastUsedAt
+    }).from(schema.apiKeys).where(eq(schema.apiKeys.keyHash, keyHash)).limit(1);
+    if (!apiKeyData) {
+      console.error("\u274C API key not found or invalid");
       return null;
     }
-    await supabase.from("api_keys").update({ last_used_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", apiKeyData.id);
-    console.error(`\u2705 API key validated for user ${apiKeyData.user_id} in team ${apiKeyData.team_id}`);
+    await db.update(schema.apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(schema.apiKeys.id, apiKeyData.id));
+    console.error(
+      `\u2705 API key validated for user ${apiKeyData.userId} in team ${apiKeyData.teamId}`
+    );
     return {
-      userId: apiKeyData.user_id,
-      teamId: apiKeyData.team_id,
-      scopes: apiKeyData.scopes || []
+      userId: apiKeyData.userId,
+      teamId: apiKeyData.teamId,
+      scopes: apiKeyData.scopes ?? []
     };
   } catch (error) {
     console.error("\u{1F4A5} API key validation error:", error);
@@ -68,54 +207,35 @@ async function validateApiKey(key) {
   }
 }
 var authContext = null;
-function isImageFile(mimeType) {
-  return mimeType.startsWith("image/") && ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"].includes(mimeType);
-}
-async function downloadImageAsBase64(storageKey) {
-  try {
-    const { data: urlData, error: urlError } = await supabase.storage.from("vault").createSignedUrl(storageKey, 3600);
-    if (urlError || !urlData?.signedUrl) {
-      console.error(`Failed to create signed URL for ${storageKey}:`, urlError);
-      return null;
-    }
-    const response = await fetch(urlData.signedUrl);
-    if (!response.ok) {
-      console.error(`Failed to download file ${storageKey}: ${response.status}`);
-      return null;
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
-    return buffer.toString("base64");
-  } catch (error) {
-    console.error(`Error downloading image ${storageKey}:`, error);
-    return null;
-  }
-}
 async function getGithubTokenForProject(projectId, teamId) {
   try {
-    const { data: repoData, error: repoError } = await supabase.from("project_github_repositories").select("repository_full_name").eq("project_id", projectId).eq("team_id", teamId).single();
-    if (repoError || !repoData) {
+    const [repoData] = await db.select({
+      repositoryFullName: schema.projectGithubRepositories.repositoryFullName
+    }).from(schema.projectGithubRepositories).where(
+      and(
+        eq(schema.projectGithubRepositories.projectId, projectId),
+        eq(schema.projectGithubRepositories.teamId, teamId)
+      )
+    ).limit(1);
+    if (!repoData) {
       console.error(`No GitHub repository linked to project ${projectId}`);
       return null;
     }
-    const { data: appData, error: appError } = await supabase.from("apps").select("config").eq("team_id", teamId).eq("app_id", "github").single();
-    if (appError || !appData?.config?.access_token) {
+    const [appData] = await db.select({ config: schema.apps.config }).from(schema.apps).where(
+      and(eq(schema.apps.teamId, teamId), eq(schema.apps.appId, "github"))
+    ).limit(1);
+    const accessToken = appData?.config?.access_token;
+    if (!appData || !accessToken) {
       console.error(`GitHub app not connected for team ${teamId}`);
       return null;
     }
-    const accessToken = appData.config.access_token;
-    const repositoryFullName = repoData.repository_full_name;
+    const repositoryFullName = repoData.repositoryFullName;
     const [owner, repo] = repositoryFullName.split("/");
     if (!owner || !repo) {
       console.error(`Invalid repository full name: ${repositoryFullName}`);
       return null;
     }
-    return {
-      token: accessToken,
-      repositoryFullName,
-      owner,
-      repo
-    };
+    return { token: accessToken, repositoryFullName, owner, repo };
   } catch (error) {
     console.error("Error getting GitHub token for project:", error);
     return null;
@@ -124,36 +244,40 @@ async function getGithubTokenForProject(projectId, teamId) {
 async function transitionToNextPhase(sessionId, currentPhase) {
   try {
     const now = /* @__PURE__ */ new Date();
-    const phaseOrder = ["analysis", "bug_investigation", "development", "communication"];
-    const { data: allPhases, error: fetchError } = await supabase.from("ai_time_logs").select("*").eq("ai_session_id", sessionId).order("activity_type");
-    if (fetchError || !allPhases) {
-      console.error("Failed to fetch phases for transition:", fetchError);
-      return;
-    }
+    const phaseOrder = [
+      "analysis",
+      "bug_investigation",
+      "development",
+      "communication"
+    ];
+    const allPhases = await db.select().from(schema.aiTimeLogs).where(eq(schema.aiTimeLogs.aiSessionId, sessionId)).orderBy(asc(schema.aiTimeLogs.activityType));
     let currentPhaseType = currentPhase;
     if (!currentPhaseType) {
       const activePhase = allPhases.find((p) => p.status === "in_progress");
-      currentPhaseType = activePhase?.activity_type;
+      currentPhaseType = activePhase?.activityType ?? void 0;
     }
     if (!currentPhaseType) {
-      const analysisPhase = allPhases.find((p) => p.activity_type === "analysis");
-      if (analysisPhase && analysisPhase.status === "pending" && analysisPhase.estimated_duration_seconds > 0) {
-        await supabase.from("ai_time_logs").update({
-          status: "in_progress",
-          started_at: now.toISOString()
-        }).eq("id", analysisPhase.id);
+      const analysisPhase = allPhases.find(
+        (p) => p.activityType === "analysis"
+      );
+      if (analysisPhase && analysisPhase.status === "pending" && (analysisPhase.estimatedDurationSeconds ?? 0) > 0) {
+        await db.update(schema.aiTimeLogs).set({ status: "in_progress", startedAt: now.toISOString() }).where(eq(schema.aiTimeLogs.id, analysisPhase.id));
         console.error("\u2705 Started analysis phase");
       }
       return;
     }
-    const currentPhaseRecord = allPhases.find((p) => p.activity_type === currentPhaseType && p.status === "in_progress");
+    const currentPhaseRecord = allPhases.find(
+      (p) => p.activityType === currentPhaseType && p.status === "in_progress"
+    );
     if (currentPhaseRecord) {
-      const duration = Math.round((now.getTime() - new Date(currentPhaseRecord.started_at).getTime()) / 1e3);
-      await supabase.from("ai_time_logs").update({
+      const duration = Math.round(
+        (now.getTime() - new Date(currentPhaseRecord.startedAt).getTime()) / 1e3
+      );
+      await db.update(schema.aiTimeLogs).set({
         status: "completed",
-        ended_at: now.toISOString(),
-        duration_seconds: duration
-      }).eq("id", currentPhaseRecord.id);
+        endedAt: now.toISOString(),
+        durationSeconds: duration
+      }).where(eq(schema.aiTimeLogs.id, currentPhaseRecord.id));
       console.error(`\u2705 Completed phase: ${currentPhaseType} (${duration}s)`);
     }
     const currentIndex = phaseOrder.indexOf(currentPhaseType);
@@ -163,18 +287,19 @@ async function transitionToNextPhase(sessionId, currentPhase) {
     }
     for (let i = currentIndex + 1; i < phaseOrder.length; i++) {
       const nextPhaseType = phaseOrder[i];
-      const nextPhase = allPhases.find((p) => p.activity_type === nextPhaseType);
+      const nextPhase = allPhases.find(
+        (p) => p.activityType === nextPhaseType
+      );
       if (!nextPhase) continue;
-      if (nextPhase.estimated_duration_seconds === 0) {
-        await supabase.from("ai_time_logs").update({ status: "skipped" }).eq("id", nextPhase.id);
-        console.error(`\u23ED\uFE0F Skipped phase: ${nextPhaseType} (0 minutes estimated)`);
+      if ((nextPhase.estimatedDurationSeconds ?? 0) === 0) {
+        await db.update(schema.aiTimeLogs).set({ status: "skipped" }).where(eq(schema.aiTimeLogs.id, nextPhase.id));
+        console.error(
+          `\u23ED\uFE0F Skipped phase: ${nextPhaseType} (0 minutes estimated)`
+        );
         continue;
       }
       if (nextPhase.status === "pending") {
-        await supabase.from("ai_time_logs").update({
-          status: "in_progress",
-          started_at: now.toISOString()
-        }).eq("id", nextPhase.id);
+        await db.update(schema.aiTimeLogs).set({ status: "in_progress", startedAt: now.toISOString() }).where(eq(schema.aiTimeLogs.id, nextPhase.id));
         console.error(`\u2705 Started next phase: ${nextPhaseType}`);
         return;
       }
@@ -187,7 +312,7 @@ async function transitionToNextPhase(sessionId, currentPhase) {
 var server = new Server(
   {
     name: "mg-tickets-mcp-bridge",
-    version: "2.0.0"
+    version: "3.0.0"
   },
   {
     capabilities: {
@@ -203,11 +328,27 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        status: { type: "string", enum: ["open", "in_progress", "review", "resolved", "closed", "backlog"] },
-        priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+        status: {
+          type: "string",
+          enum: [
+            "open",
+            "in_progress",
+            "review",
+            "resolved",
+            "closed",
+            "backlog"
+          ]
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "medium", "high", "critical"]
+        },
         projectId: { type: "string" },
         customerId: { type: "string" },
-        q: { type: "string", description: "Search query for ticket number, title, or description" },
+        q: {
+          type: "string",
+          description: "Search query for ticket number, title, or description"
+        },
         pageSize: { type: "number", default: 20, maximum: 100 }
       },
       required: []
@@ -232,9 +373,35 @@ var TOOLS = [
       properties: {
         title: { type: "string", description: "Ticket title" },
         description: { type: "string" },
-        status: { type: "string", enum: ["open", "in_progress", "review", "resolved", "closed", "backlog"], default: "open" },
-        priority: { type: "string", enum: ["low", "medium", "high", "critical"], default: "medium" },
-        type: { type: "string", enum: ["task", "bug", "feature", "support", "question", "improvement"], default: "task" },
+        status: {
+          type: "string",
+          enum: [
+            "open",
+            "in_progress",
+            "review",
+            "resolved",
+            "closed",
+            "backlog"
+          ],
+          default: "open"
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "medium", "high", "critical"],
+          default: "medium"
+        },
+        type: {
+          type: "string",
+          enum: [
+            "task",
+            "bug",
+            "feature",
+            "support",
+            "question",
+            "improvement"
+          ],
+          default: "task"
+        },
         projectId: { type: "string" },
         customerId: { type: "string" }
       },
@@ -247,7 +414,10 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        q: { type: "string", description: "Search query for customer name or email" },
+        q: {
+          type: "string",
+          description: "Search query for customer name or email"
+        },
         pageSize: { type: "number", default: 20, maximum: 100 }
       },
       required: []
@@ -288,12 +458,15 @@ var TOOLS = [
         name: { type: "string", description: "Project name" },
         description: { type: "string" },
         customerId: { type: "string" },
-        status: { type: "string", enum: ["active", "on_hold", "completed", "cancelled"], default: "active" }
+        status: {
+          type: "string",
+          enum: ["active", "on_hold", "completed", "cancelled"],
+          default: "active"
+        }
       },
       required: ["name"]
     }
   },
-  // === NEW AI SESSION TOOLS ===
   {
     name: "start-ai-session-smart",
     description: "Start a new AI development session with automatic tracking",
@@ -302,7 +475,10 @@ var TOOLS = [
       properties: {
         ticketId: { type: "string" },
         ticketUrl: { type: "string", description: "URL to the ticket" },
-        cursorSessionId: { type: "string", description: "Cursor session identifier" },
+        cursorSessionId: {
+          type: "string",
+          description: "Cursor session identifier"
+        },
         totalEstimatedMinutes: {
           type: "number",
           description: "Total estimated time in minutes (senior dev WITHOUT AI, rounded to 15 min)"
@@ -329,7 +505,12 @@ var TOOLS = [
         developerFollowUp: { type: "string" },
         followUpReason: {
           type: "string",
-          enum: ["incomplete_result", "wrong_approach", "needs_clarification", "error_in_code"]
+          enum: [
+            "incomplete_result",
+            "wrong_approach",
+            "needs_clarification",
+            "error_in_code"
+          ]
         },
         outcome: {
           type: "string",
@@ -345,7 +526,15 @@ var TOOLS = [
           description: "Detailed work description generated by AI (2-3 sentences, summarizing all work done in session including follow-ups)"
         }
       },
-      required: ["aiSessionId", "originalPrompt", "aiResponse", "developerFollowUp", "followUpReason", "estimatedMinutes", "workDescription"]
+      required: [
+        "aiSessionId",
+        "originalPrompt",
+        "aiResponse",
+        "developerFollowUp",
+        "followUpReason",
+        "estimatedMinutes",
+        "workDescription"
+      ]
     }
   },
   {
@@ -374,9 +563,15 @@ var TOOLS = [
           items: {
             type: "object",
             properties: {
-              todoId: { type: "string", description: "Optional external todo ID for tracking" },
+              todoId: {
+                type: "string",
+                description: "Optional external todo ID for tracking"
+              },
               content: { type: "string" },
-              status: { type: "string", enum: ["pending", "in_progress", "completed", "cancelled"] },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed", "cancelled"]
+              },
               estimatedMinutes: { type: "number" }
             },
             required: ["content", "status"]
@@ -404,7 +599,11 @@ var TOOLS = [
             type: "object",
             properties: {
               content: { type: "string" },
-              status: { type: "string", enum: ["pending", "in_progress"], default: "pending" },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress"],
+                default: "pending"
+              },
               estimatedMinutes: { type: "number" },
               addedInFollowUp: { type: "boolean", default: true }
             },
@@ -457,7 +656,10 @@ var TOOLS = [
       type: "object",
       properties: {
         aiSessionId: { type: "string" },
-        customerResponse: { type: "string", description: "Customer response generated by Cursor AI" },
+        customerResponse: {
+          type: "string",
+          description: "Customer response generated by Cursor AI"
+        },
         responseType: {
           type: "string",
           enum: ["completion", "progress_update", "needs_clarification"],
@@ -526,17 +728,13 @@ var TOOLS = [
       required: ["workDescription", "estimatedHours"]
     }
   },
-  // === GITHUB TOOLS ===
   {
     name: "get-github-file",
     description: "Get the contents of a specific file from a GitHub repository. Use this after finding relevant files to read their full content.",
     inputSchema: {
       type: "object",
       properties: {
-        projectId: {
-          type: "string",
-          description: "Project ID (UUID)"
-        },
+        projectId: { type: "string", description: "Project ID (UUID)" },
         filePath: {
           type: "string",
           description: 'Full path to the file in the repository (e.g., "src/components/Button.tsx")'
@@ -555,10 +753,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        projectId: {
-          type: "string",
-          description: "Project ID (UUID)"
-        },
+        projectId: { type: "string", description: "Project ID (UUID)" },
         directoryPath: {
           type: "string",
           description: 'Path to directory (e.g., "src/components"). Use empty string or "/" for root directory.'
@@ -592,276 +787,387 @@ var RESOURCES = [
     mimeType: "application/json"
   }
 ];
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return { tools: TOOLS };
-});
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  return { resources: RESOURCES };
-});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: RESOURCES
+}));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   if (!authContext) {
     return {
-      content: [{ type: "text", text: "Error: Not authenticated. API key validation failed." }]
+      content: [
+        {
+          type: "text",
+          text: "Error: Not authenticated. API key validation failed."
+        }
+      ]
     };
   }
   const { name, arguments: args2 } = request.params;
   console.error(`\u{1F6E0}\uFE0F  Executing tool: ${name} for team ${authContext.teamId}`);
   try {
     switch (name) {
-      case "get-tickets": {
-        const { status, priority, projectId, customerId, q, pageSize = 20 } = args2;
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-        const customerIds = await getAccessibleCustomerIds(authContext.teamId);
-        let teamFilter = `team_id.in.(${teamIds.join(",")})`;
-        let projectFilter = projectIds.length > 0 ? `project_id.in.(${projectIds.join(",")})` : null;
-        let customerFilter = customerIds.length > 0 ? `customer_id.in.(${customerIds.join(",")})` : null;
-        const filters = [teamFilter, projectFilter, customerFilter].filter(Boolean);
-        let query = supabase.from("tickets").select(`
-            id,
-            ticket_number,
-            title,
-            description,
-            status,
-            priority,
-            type,
-            created_at,
-            project_id,
-            customer_id,
-            projects:project_id(id, name),
-            customers:customer_id(id, name)
-          `).or(filters.join(",")).limit(Math.min(pageSize, 100));
-        if (status) query = query.eq("status", status);
-        if (priority) query = query.eq("priority", priority);
-        if (projectId) query = query.eq("project_id", projectId);
-        if (customerId) query = query.eq("customer_id", customerId);
-        if (q) query = query.or(`ticket_number.ilike.%${q}%,title.ilike.%${q}%,description.ilike.%${q}%`);
-        const { data, error } = await query.order("created_at", { ascending: false });
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `Found ${data?.length || 0} tickets:
+      case "get-tickets":
+        return await handleGetTickets(asToolArgs(args2));
+      case "get-ticket-by-id":
+        return await handleGetTicketById(asToolArgs(args2));
+      case "create-ticket":
+        return await handleCreateTicket(asToolArgs(args2));
+      case "get-customers":
+        return await handleGetCustomers(asToolArgs(args2));
+      case "create-customer":
+        return await handleCreateCustomer(asToolArgs(args2));
+      case "get-projects":
+        return await handleGetProjects(asToolArgs(args2));
+      case "create-project":
+        return await handleCreateProject(asToolArgs(args2));
+      case "start-ai-session-smart":
+        return await handleStartAiSession(
+          asToolArgs(args2)
+        );
+      case "track-manual-follow-up":
+        return await handleTrackManualFollowUp(
+          asToolArgs(args2)
+        );
+      case "get-session-context":
+        return await handleGetSessionContext(
+          asToolArgs(args2)
+        );
+      case "sync-session-todos":
+        return await handleSyncSessionTodos(
+          asToolArgs(args2)
+        );
+      case "add-follow-up-todos":
+        return await handleAddFollowUpTodos(
+          asToolArgs(args2)
+        );
+      case "update-session-status":
+        return await handleUpdateSessionStatus(
+          asToolArgs(args2)
+        );
+      case "get-completion-context":
+        return await handleGetCompletionContext(
+          asToolArgs(args2)
+        );
+      case "save-customer-response":
+        return await handleSaveCustomerResponse(
+          asToolArgs(args2)
+        );
+      case "complete-ai-session":
+        return await handleCompleteAiSession(
+          asToolArgs(args2)
+        );
+      case "log-hours":
+        return await handleLogHours(asToolArgs(args2));
+      case "get-github-file":
+        return await handleGetGithubFile(asToolArgs(args2));
+      case "list-github-directory":
+        return await handleListGithubDirectory(
+          asToolArgs(args2)
+        );
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    console.error("\u274C Tool execution error:", error);
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error);
+    return {
+      content: [{ type: "text", text: `Error executing ${name}: ${message}` }]
+    };
+  }
+});
+async function handleGetTickets(input) {
+  const ctx = authContext;
+  const { status, priority, projectId, customerId, q, pageSize = 20 } = input;
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
+  const customerIds = await getAccessibleCustomerIds(ctx.teamId);
+  const accessPredicate = buildTicketAccessPredicate(
+    teamIds,
+    projectIds,
+    customerIds
+  );
+  const filters = [accessPredicate, eq(schema.tickets.isDeleted, false)];
+  if (status) filters.push(eq(schema.tickets.status, status));
+  if (priority) filters.push(eq(schema.tickets.priority, priority));
+  if (projectId) filters.push(eq(schema.tickets.projectId, projectId));
+  if (customerId) filters.push(eq(schema.tickets.customerId, customerId));
+  if (q) {
+    const pattern = `%${q}%`;
+    filters.push(
+      or(
+        ilike(schema.tickets.ticketNumber, pattern),
+        ilike(schema.tickets.title, pattern),
+        ilike(schema.tickets.description, pattern)
+      )
+    );
+  }
+  const rows = await db.select({
+    id: schema.tickets.id,
+    ticketNumber: schema.tickets.ticketNumber,
+    title: schema.tickets.title,
+    description: schema.tickets.description,
+    status: schema.tickets.status,
+    priority: schema.tickets.priority,
+    type: schema.tickets.type,
+    createdAt: schema.tickets.createdAt,
+    projectId: schema.tickets.projectId,
+    customerId: schema.tickets.customerId,
+    projectName: schema.projects.name,
+    customerName: schema.customers.name
+  }).from(schema.tickets).leftJoin(schema.projects, eq(schema.projects.id, schema.tickets.projectId)).leftJoin(
+    schema.customers,
+    eq(schema.customers.id, schema.tickets.customerId)
+  ).where(and(...filters)).orderBy(desc(schema.tickets.createdAt)).limit(Math.min(pageSize, 100));
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${rows.length} tickets:
 
-${data?.map(
-              (ticket) => `**${ticket.ticket_number}**: ${ticket.title}
-Status: ${ticket.status} | Priority: ${ticket.priority}
-${ticket.projects?.name ? `Project: ${ticket.projects.name}
-` : ""}${ticket.customers?.name ? `Customer: ${ticket.customers.name}
-` : ""}Created: ${new Date(ticket.created_at).toLocaleDateString()}
+${rows.map(
+          (t) => `**${t.ticketNumber}**: ${t.title}
+Status: ${t.status} | Priority: ${t.priority}
+${t.projectName ? `Project: ${t.projectName}
+` : ""}${t.customerName ? `Customer: ${t.customerName}
+` : ""}Created: ${new Date(t.createdAt).toLocaleDateString()}
 `
-            ).join("\n") || "No tickets found."}`
-          }]
-        };
+        ).join("\n") || "No tickets found."}`
       }
-      case "get-ticket-by-id": {
-        const { id } = args2;
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-        const customerIds = await getAccessibleCustomerIds(authContext.teamId);
-        let accessFilter = `team_id.in.(${teamIds.join(",")})`;
-        if (projectIds.length > 0) accessFilter += `,project_id.in.(${projectIds.join(",")})`;
-        if (customerIds.length > 0) accessFilter += `,customer_id.in.(${customerIds.join(",")})`;
-        const { data: ticketData, error } = await supabase.from("tickets").select(`
-            *,
-            projects:project_id(id, name),
-            customers:customer_id(id, name),
-            assignee:assignee_id(id, full_name, email),
-            requester:requester_id(id, full_name, email)
-          `).eq("id", id).single();
-        if (error) {
-          if (error.code === "PGRST116") {
-            throw new Error(`Ticket not found: ${id}`);
-          }
-          throw new Error(error.message || JSON.stringify(error));
-        }
-        let hasAccess = false;
-        if (teamIds.includes(ticketData.team_id)) {
-          hasAccess = true;
-        }
-        if (!hasAccess && ticketData.project_id && projectIds.includes(ticketData.project_id)) {
-          hasAccess = true;
-        }
-        if (!hasAccess && ticketData.customer_id && customerIds.includes(ticketData.customer_id)) {
-          hasAccess = true;
-        }
-        if (!hasAccess) {
-          throw new Error("Access denied: You do not have permission to view this ticket");
-        }
-        const data = ticketData;
-        if (error) {
-          if (error.code === "PGRST116") {
-            throw new Error(`Ticket not found or no access: ${id}`);
-          }
-          throw new Error(error.message || JSON.stringify(error));
-        }
-        const { data: attachments, error: attachmentsError } = await supabase.from("ticket_attachments").select(`
-            id,
-            file_name,
-            file_size,
-            mime_type,
-            storage_key,
-            created_at,
-            users:user_id(id, full_name)
-          `).eq("ticket_id", id).order("created_at", { ascending: true });
-        if (attachmentsError) {
-          console.error("Error fetching attachments:", attachmentsError);
-        }
-        const { data: comments, error: commentsError } = await supabase.from("ticket_comments").select(`
-            id,
-            content,
-            created_at,
-            users:user_id(id, full_name)
-          `).eq("ticket_id", id).order("created_at", { ascending: true });
-        if (commentsError) {
-          console.error("Error fetching comments:", commentsError);
-        }
-        const commentIds = comments?.map((c) => c.id) || [];
-        let commentAttachments = [];
-        if (commentIds.length > 0) {
-          const { data: commAttachments, error: commAttachmentsError } = await supabase.from("ticket_comment_attachments").select(`
-              id,
-              comment_id,
-              file_name,
-              file_size,
-              mime_type,
-              storage_key,
-              created_at
-            `).in("comment_id", commentIds);
-          if (commAttachmentsError) {
-            console.error("Error fetching comment attachments:", commAttachmentsError);
-          } else {
-            commentAttachments = commAttachments || [];
-          }
-        }
-        const content = [{
-          type: "text",
-          text: `**Ticket Details:**
+    ]
+  };
+}
+async function handleGetTicketById(input) {
+  const ctx = authContext;
+  const { id } = input;
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
+  const customerIds = await getAccessibleCustomerIds(ctx.teamId);
+  const ticketRow = await db.query.tickets.findFirst({
+    where: eq(schema.tickets.id, id),
+    with: {
+      project: { columns: { id: true, name: true } },
+      customer: { columns: { id: true, name: true } },
+      assignee: { columns: { id: true, fullName: true, email: true } },
+      requester: { columns: { id: true, fullName: true, email: true } }
+    }
+  });
+  if (!ticketRow) {
+    throw new Error(`Ticket not found: ${id}`);
+  }
+  let hasAccess = false;
+  if (teamIds.includes(ticketRow.teamId)) hasAccess = true;
+  if (!hasAccess && ticketRow.projectId && projectIds.includes(ticketRow.projectId))
+    hasAccess = true;
+  if (!hasAccess && ticketRow.customerId && customerIds.includes(ticketRow.customerId))
+    hasAccess = true;
+  if (!hasAccess) {
+    throw new Error(
+      "Access denied: You do not have permission to view this ticket"
+    );
+  }
+  const attachments = await db.select({
+    id: schema.ticketAttachments.id,
+    fileName: schema.ticketAttachments.fileName,
+    fileSize: schema.ticketAttachments.fileSize,
+    mimeType: schema.ticketAttachments.mimeType,
+    storageKey: schema.ticketAttachments.storageKey,
+    createdAt: schema.ticketAttachments.createdAt,
+    uploaderId: schema.ticketAttachments.userId,
+    uploaderName: schema.users.fullName
+  }).from(schema.ticketAttachments).leftJoin(
+    schema.users,
+    eq(schema.users.id, schema.ticketAttachments.userId)
+  ).where(eq(schema.ticketAttachments.ticketId, id)).orderBy(asc(schema.ticketAttachments.createdAt));
+  const comments = await db.select({
+    id: schema.ticketComments.id,
+    content: schema.ticketComments.content,
+    createdAt: schema.ticketComments.createdAt,
+    userId: schema.ticketComments.userId
+  }).from(schema.ticketComments).where(eq(schema.ticketComments.ticketId, id)).orderBy(asc(schema.ticketComments.createdAt));
+  const commentUserIds = [
+    ...new Set(
+      comments.map((c) => c.userId).filter((v) => Boolean(v))
+    )
+  ];
+  const commentUserMap = /* @__PURE__ */ new Map();
+  if (commentUserIds.length > 0) {
+    const commentUsers = await db.select({ id: schema.users.id, fullName: schema.users.fullName }).from(schema.users).where(inArray(schema.users.id, commentUserIds));
+    commentUsers.forEach((u) => commentUserMap.set(u.id, u));
+  }
+  const commentIds = comments.map((c) => c.id);
+  const commentAttachments = commentIds.length > 0 ? await db.select({
+    id: schema.ticketCommentAttachments.id,
+    commentId: schema.ticketCommentAttachments.commentId,
+    fileName: schema.ticketCommentAttachments.fileName,
+    fileSize: schema.ticketCommentAttachments.fileSize,
+    mimeType: schema.ticketCommentAttachments.mimeType,
+    storageKey: schema.ticketCommentAttachments.storageKey,
+    createdAt: schema.ticketCommentAttachments.createdAt
+  }).from(schema.ticketCommentAttachments).where(
+    inArray(schema.ticketCommentAttachments.commentId, commentIds)
+  ) : [];
+  const content = [
+    {
+      type: "text",
+      text: `**Ticket Details:**
 
-**${data.ticket_number}**: ${data.title}
-Status: ${data.status}
-Priority: ${data.priority}
-Type: ${data.type}
-${data.description ? `Description: ${data.description}
-` : ""}${data.projects?.name ? `Project: ${data.projects.name}
-` : ""}${data.customers?.name ? `Customer: ${data.customers.name}
-` : ""}${data.assignee?.full_name ? `Assignee: ${data.assignee.full_name}
-` : ""}Requester: ${data.requester?.full_name || "Unknown"}
-Created: ${new Date(data.created_at).toLocaleDateString()}
-${attachments && attachments.length > 0 ? `
+**${ticketRow.ticketNumber}**: ${ticketRow.title}
+Status: ${ticketRow.status}
+Priority: ${ticketRow.priority}
+Type: ${ticketRow.type}
+${ticketRow.description ? `Description: ${ticketRow.description}
+` : ""}${ticketRow.project?.name ? `Project: ${ticketRow.project.name}
+` : ""}${ticketRow.customer?.name ? `Customer: ${ticketRow.customer.name}
+` : ""}${ticketRow.assignee?.fullName ? `Assignee: ${ticketRow.assignee.fullName}
+` : ""}Requester: ${ticketRow.requester?.fullName || "Unknown"}
+Created: ${new Date(ticketRow.createdAt).toLocaleDateString()}
+${attachments.length > 0 ? `
 \u{1F4CE} Attachments: ${attachments.length}
-` : ""}${comments && comments.length > 0 ? `\u{1F4AC} Comments: ${comments.length}
+` : ""}${comments.length > 0 ? `\u{1F4AC} Comments: ${comments.length}
 ` : ""}`
-        }];
-        if (attachments && attachments.length > 0) {
-          console.error(`\u{1F4CE} Processing ${attachments.length} ticket attachments...`);
-          for (const attachment of attachments) {
-            if (isImageFile(attachment.mime_type)) {
-              console.error(`\u{1F5BC}\uFE0F  Downloading image: ${attachment.file_name}`);
-              const base64Data = await downloadImageAsBase64(attachment.storage_key);
-              if (base64Data) {
-                content.push({
-                  type: "image",
-                  data: base64Data,
-                  mimeType: attachment.mime_type
-                });
-                content.push({
-                  type: "text",
-                  text: `
-\u{1F4F8} **Image from ticket**: ${attachment.file_name} (${Math.round(attachment.file_size / 1024)}KB, uploaded by ${attachment.users?.full_name || "Unknown"} on ${new Date(attachment.created_at).toLocaleDateString()})
+    }
+  ];
+  if (attachments.length > 0) {
+    console.error(`\u{1F4CE} Processing ${attachments.length} ticket attachments...`);
+    for (const attachment of attachments) {
+      if (isImageFile(attachment.mimeType)) {
+        console.error(`\u{1F5BC}\uFE0F  Downloading image: ${attachment.fileName}`);
+        const base64 = await downloadImageAsBase64(attachment.storageKey);
+        if (base64) {
+          content.push({
+            type: "image",
+            data: base64,
+            mimeType: attachment.mimeType
+          });
+          content.push({
+            type: "text",
+            text: `
+\u{1F4F8} **Image from ticket**: ${attachment.fileName} (${Math.round(
+              attachment.fileSize / 1024
+            )}KB, uploaded by ${attachment.uploaderName || "Unknown"} on ${new Date(
+              attachment.createdAt
+            ).toLocaleDateString()})
 `
-                });
-              }
-            }
-          }
+          });
         }
-        if (commentAttachments.length > 0) {
-          console.error(`\u{1F4CE} Processing ${commentAttachments.length} comment attachments...`);
-          for (const attachment of commentAttachments) {
-            if (isImageFile(attachment.mime_type)) {
-              console.error(`\u{1F5BC}\uFE0F  Downloading comment image: ${attachment.file_name}`);
-              const base64Data = await downloadImageAsBase64(attachment.storage_key);
-              if (base64Data) {
-                const comment = comments?.find((c) => c.id === attachment.comment_id);
-                content.push({
-                  type: "image",
-                  data: base64Data,
-                  mimeType: attachment.mime_type
-                });
-                content.push({
-                  type: "text",
-                  text: `
-\u{1F4F8} **Image from comment** by ${comment?.users?.full_name || "Unknown"} on ${new Date(attachment.created_at).toLocaleDateString()}: ${attachment.file_name} (${Math.round(attachment.file_size / 1024)}KB)
+      }
+    }
+  }
+  if (commentAttachments.length > 0) {
+    console.error(
+      `\u{1F4CE} Processing ${commentAttachments.length} comment attachments...`
+    );
+    for (const attachment of commentAttachments) {
+      if (isImageFile(attachment.mimeType)) {
+        console.error(
+          `\u{1F5BC}\uFE0F  Downloading comment image: ${attachment.fileName}`
+        );
+        const base64 = await downloadImageAsBase64(attachment.storageKey);
+        if (base64) {
+          const comment = comments.find((c) => c.id === attachment.commentId);
+          const author = comment?.userId ? commentUserMap.get(comment.userId)?.fullName : null;
+          content.push({
+            type: "image",
+            data: base64,
+            mimeType: attachment.mimeType
+          });
+          content.push({
+            type: "text",
+            text: `
+\u{1F4F8} **Image from comment** by ${author || "Unknown"} on ${new Date(
+              attachment.createdAt
+            ).toLocaleDateString()}: ${attachment.fileName} (${Math.round(
+              attachment.fileSize / 1024
+            )}KB)
 ` + (comment?.content ? `Comment text: "${comment.content.substring(0, 100)}${comment.content.length > 100 ? "..." : ""}"
 ` : "")
-                });
-              }
-            }
-          }
+          });
         }
-        console.error(`\u2705 Returning ticket with ${content.filter((c) => c.type === "image").length} images`);
-        return { content };
       }
-      case "create-ticket": {
-        const { title, description, status = "open", priority = "medium", type = "task", projectId, customerId } = args2;
-        const year = (/* @__PURE__ */ new Date()).getFullYear();
-        let resolvedTeamId = authContext.teamId;
-        let resolvedCustomerId = customerId;
-        let projectAbbreviation = "";
-        if (projectId) {
-          const { data: project } = await supabase.from("projects").select("name, team_id, customer_id").eq("id", projectId).single();
-          if (project) {
-            if (project.team_id) {
-              resolvedTeamId = project.team_id;
-            }
-            if (!resolvedCustomerId && project.customer_id) {
-              resolvedCustomerId = project.customer_id;
-            }
-            if (project.name) {
-              const name2 = project.name.toUpperCase().replace(/[^A-Z0-9\s]/g, "");
-              const words = name2.split(/\s+/).filter(Boolean);
-              if (words.length >= 2) {
-                projectAbbreviation = words.slice(0, 2).map((w) => w.substring(0, 3)).join("").substring(0, 5);
-              } else if (words.length === 1 && words[0]) {
-                projectAbbreviation = words[0].substring(0, 5);
-              }
-            }
-          }
-        }
-        let ticketNumber;
-        if (projectId && projectAbbreviation) {
-          const pattern = `${year}-${projectAbbreviation}-%`;
-          const { data: existingTickets } = await supabase.from("tickets").select("ticket_number").eq("project_id", projectId).like("ticket_number", pattern).order("ticket_number", { ascending: false }).limit(1);
-          let nextSequence = 1;
-          if (existingTickets && existingTickets.length > 0 && existingTickets[0]?.ticket_number) {
-            const parts = existingTickets[0].ticket_number.split("-");
-            if (parts.length === 3) {
-              const lastSeq = parseInt(parts[2], 10);
-              if (!isNaN(lastSeq)) nextSequence = lastSeq + 1;
-            }
-          }
-          ticketNumber = `${year}-${projectAbbreviation}-${String(nextSequence).padStart(3, "0")}`;
-        } else {
-          const { count } = await supabase.from("tickets").select("*", { count: "exact", head: true }).eq("team_id", resolvedTeamId);
-          ticketNumber = `${year}-${String((count || 0) + 1).padStart(3, "0")}`;
+    }
+  }
+  console.error(
+    `\u2705 Returning ticket with ${content.filter((c) => c.type === "image").length} images`
+  );
+  return { content };
+}
+async function handleCreateTicket(input) {
+  const ctx = authContext;
+  const {
+    title,
+    description,
+    status = "open",
+    priority = "medium",
+    type = "task",
+    projectId,
+    customerId
+  } = input;
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  let resolvedTeamId = ctx.teamId;
+  let resolvedCustomerId = customerId;
+  let projectAbbreviation = "";
+  if (projectId) {
+    const [project] = await db.select({
+      name: schema.projects.name,
+      teamId: schema.projects.teamId,
+      customerId: schema.projects.customerId
+    }).from(schema.projects).where(eq(schema.projects.id, projectId)).limit(1);
+    if (project) {
+      if (project.teamId) resolvedTeamId = project.teamId;
+      if (!resolvedCustomerId && project.customerId) {
+        resolvedCustomerId = project.customerId;
+      }
+      if (project.name) {
+        const upper = project.name.toUpperCase().replace(/[^A-Z0-9\s]/g, "");
+        const words = upper.split(/\s+/).filter(Boolean);
+        if (words.length >= 2) {
+          projectAbbreviation = words.slice(0, 2).map((w) => w.substring(0, 3)).join("").substring(0, 5);
+        } else if (words.length === 1 && words[0]) {
+          projectAbbreviation = words[0].substring(0, 5);
         }
-        const { data, error } = await supabase.from("tickets").insert({
-          team_id: resolvedTeamId,
-          ticket_number: ticketNumber,
-          title,
-          description,
-          status,
-          priority,
-          type,
-          project_id: projectId || null,
-          customer_id: resolvedCustomerId || null,
-          requester_id: authContext.userId
-        }).select().single();
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `\u2705 **Ticket Created Successfully!**
+      }
+    }
+  }
+  let ticketNumber;
+  if (projectId && projectAbbreviation) {
+    const pattern = `${year}-${projectAbbreviation}-%`;
+    const [highest] = await db.select({ ticketNumber: schema.tickets.ticketNumber }).from(schema.tickets).where(
+      and(
+        eq(schema.tickets.projectId, projectId),
+        ilike(schema.tickets.ticketNumber, pattern)
+      )
+    ).orderBy(desc(schema.tickets.ticketNumber)).limit(1);
+    let nextSequence = 1;
+    if (highest?.ticketNumber) {
+      const parts = highest.ticketNumber.split("-");
+      if (parts.length === 3 && parts[2]) {
+        const lastSeq = Number.parseInt(parts[2], 10);
+        if (!Number.isNaN(lastSeq)) nextSequence = lastSeq + 1;
+      }
+    }
+    ticketNumber = `${year}-${projectAbbreviation}-${String(nextSequence).padStart(3, "0")}`;
+  } else {
+    const [countRow] = await db.select({ n: sql`count(*)::int` }).from(schema.tickets).where(eq(schema.tickets.teamId, resolvedTeamId));
+    const count = Number(countRow?.n ?? 0);
+    ticketNumber = `${year}-${String(count + 1).padStart(3, "0")}`;
+  }
+  await db.insert(schema.tickets).values({
+    teamId: resolvedTeamId,
+    ticketNumber,
+    title,
+    description: description ?? null,
+    status,
+    priority,
+    type,
+    projectId: projectId ?? null,
+    customerId: resolvedCustomerId ?? null,
+    requesterId: ctx.userId
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Ticket Created Successfully!**
 
 Ticket Number: **${ticketNumber}**
 Title: ${title}
@@ -869,143 +1175,179 @@ Status: ${status}
 Priority: ${priority}
 Type: ${type}
 `
-          }]
-        };
       }
-      case "get-customers": {
-        const { q, pageSize = 20 } = args2;
-        const customerIds = await getAccessibleCustomerIds(authContext.teamId);
-        if (customerIds.length === 0) {
-          return {
-            content: [{
-              type: "text",
-              text: "No customers found or no access to any customers."
-            }]
-          };
+    ]
+  };
+}
+async function handleGetCustomers(input) {
+  const ctx = authContext;
+  const { q, pageSize = 20 } = input;
+  const customerIds = await getAccessibleCustomerIds(ctx.teamId);
+  if (customerIds.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No customers found or no access to any customers."
         }
-        let query = supabase.from("customers").select("id, name, email, website, created_at").in("id", customerIds).limit(Math.min(pageSize, 100));
-        if (q) query = query.or(`name.ilike.%${q}%,email.ilike.%${q}%`);
-        const { data, error } = await query.order("name");
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `Found ${data?.length || 0} customers:
+      ]
+    };
+  }
+  const filters = [inArray(schema.customers.id, customerIds)];
+  if (q) {
+    const pattern = `%${q}%`;
+    filters.push(
+      or(
+        ilike(schema.customers.name, pattern),
+        ilike(schema.customers.email, pattern)
+      )
+    );
+  }
+  const rows = await db.select({
+    id: schema.customers.id,
+    name: schema.customers.name,
+    email: schema.customers.email,
+    website: schema.customers.website,
+    createdAt: schema.customers.createdAt
+  }).from(schema.customers).where(and(...filters)).orderBy(asc(schema.customers.name)).limit(Math.min(pageSize, 100));
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${rows.length} customers:
 
-${data?.map(
-              (customer) => `**${customer.name}**
-${customer.email ? `Email: ${customer.email}
-` : ""}${customer.website ? `Website: ${customer.website}
-` : ""}Created: ${new Date(customer.created_at).toLocaleDateString()}
+${rows.map(
+          (c) => `**${c.name}**
+${c.email ? `Email: ${c.email}
+` : ""}${c.website ? `Website: ${c.website}
+` : ""}Created: ${new Date(c.createdAt).toLocaleDateString()}
 `
-            ).join("\n") || "No customers found."}`
-          }]
-        };
+        ).join("\n") || "No customers found."}`
       }
-      case "create-customer": {
-        const { name: name2, email, website } = args2;
-        const { data, error } = await supabase.from("customers").insert({
-          team_id: authContext.teamId,
-          name: name2,
-          email: email || null,
-          website: website || null,
-          user_id: authContext.userId
-        }).select().single();
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `\u2705 **Customer Created Successfully!**
+    ]
+  };
+}
+async function handleCreateCustomer(input) {
+  const ctx = authContext;
+  const { name, email, website } = input;
+  await db.insert(schema.customers).values({
+    teamId: ctx.teamId,
+    name,
+    email: email ?? "",
+    website: website ?? null
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Customer Created Successfully!**
 
-Name: ${name2}
+Name: ${name}
 ${email ? `Email: ${email}
 ` : ""}${website ? `Website: ${website}
 ` : ""}`
-          }]
-        };
       }
-      case "get-projects": {
-        const { customerId, q, pageSize = 20 } = args2;
-        const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-        if (projectIds.length === 0) {
-          return {
-            content: [{
-              type: "text",
-              text: "No projects found or no access to any projects."
-            }]
-          };
+    ]
+  };
+}
+async function handleGetProjects(input) {
+  const ctx = authContext;
+  const { customerId, q, pageSize = 20 } = input;
+  const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
+  if (projectIds.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No projects found or no access to any projects."
         }
-        let query = supabase.from("projects").select(`
-            id,
-            name,
-            description,
-            customer_id,
-            created_at
-          `).in("id", projectIds).limit(Math.min(pageSize, 100));
-        if (customerId) query = query.eq("customer_id", customerId);
-        if (q) query = query.ilike("name", `%${q}%`);
-        const { data, error } = await query.order("name");
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `Found ${data?.length || 0} projects:
+      ]
+    };
+  }
+  const filters = [inArray(schema.projects.id, projectIds)];
+  if (customerId) filters.push(eq(schema.projects.customerId, customerId));
+  if (q) filters.push(ilike(schema.projects.name, `%${q}%`));
+  const rows = await db.select({
+    id: schema.projects.id,
+    name: schema.projects.name,
+    description: schema.projects.description,
+    customerId: schema.projects.customerId,
+    createdAt: schema.projects.createdAt
+  }).from(schema.projects).where(and(...filters)).orderBy(asc(schema.projects.name)).limit(Math.min(pageSize, 100));
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${rows.length} projects:
 
-${data?.map(
-              (project) => `**${project.name}** (ID: ${project.id})
-${project.description ? `Description: ${project.description}
-` : ""}Created: ${new Date(project.created_at).toLocaleDateString()}
+${rows.map(
+          (p) => `**${p.name}** (ID: ${p.id})
+${p.description ? `Description: ${p.description}
+` : ""}Created: ${new Date(p.createdAt).toLocaleDateString()}
 `
-            ).join("\n") || "No projects found."}`
-          }]
-        };
+        ).join("\n") || "No projects found."}`
       }
-      case "create-project": {
-        const { name: name2, description, customerId, status = "active" } = args2;
-        const { data, error } = await supabase.from("projects").insert({
-          team_id: authContext.teamId,
-          name: name2,
-          description: description || null,
-          customer_id: customerId || null,
-          status,
-          user_id: authContext.userId
-        }).select().single();
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `\u2705 **Project Created Successfully!**
+    ]
+  };
+}
+async function handleCreateProject(input) {
+  const ctx = authContext;
+  const { name, description, customerId } = input;
+  await db.insert(schema.projects).values({
+    teamId: ctx.teamId,
+    name,
+    description: description ?? null,
+    customerId: customerId ?? null
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Project Created Successfully!**
 
-Name: ${name2}
-Status: ${status}
+Name: ${name}
 ${description ? `Description: ${description}
 ` : ""}`
-          }]
-        };
       }
-      // === AI SESSION TOOLS ===
-      case "start-ai-session-smart": {
-        const { ticketId, ticketUrl, cursorSessionId, totalEstimatedMinutes, complexityScore } = args2;
-        if (!totalEstimatedMinutes) {
-          throw new Error("totalEstimatedMinutes is required");
-        }
-        const roundedMinutes = roundToNearest15Minutes(totalEstimatedMinutes);
-        const sessionStartTime = /* @__PURE__ */ new Date();
-        const { data: sessionData, error } = await supabase.from("ai_sessions").insert({
-          ticket_id: ticketId,
-          provider_user_id: authContext.userId,
-          team_id: authContext.teamId,
-          cursor_session_id: cursorSessionId || null,
-          ai_time_estimate_minutes: roundedMinutes,
-          complexity_score: complexityScore || null,
-          status: "in_progress"
-        }).select("id, ticket_id, cursor_session_id, created_at").single();
-        if (error) throw error;
-        const sessionId = `ai-sess-${sessionData.id.substring(0, 8)}`;
-        return {
-          content: [{
-            type: "text",
-            text: `\u{1F680} **AI Session Started!**
+    ]
+  };
+}
+async function handleStartAiSession(input) {
+  const ctx = authContext;
+  const {
+    ticketId,
+    cursorSessionId,
+    totalEstimatedMinutes,
+    complexityScore
+  } = input;
+  if (!totalEstimatedMinutes) {
+    throw new Error("totalEstimatedMinutes is required");
+  }
+  const roundedMinutes = roundToNearest15Minutes(totalEstimatedMinutes);
+  const sessionStartTime = /* @__PURE__ */ new Date();
+  const [sessionData] = await db.insert(schema.aiSessions).values({
+    ticketId,
+    providerUserId: ctx.userId,
+    teamId: ctx.teamId,
+    cursorSessionId: cursorSessionId ?? null,
+    aiTimeEstimateMinutes: roundedMinutes,
+    complexityScore: complexityScore ?? null,
+    status: "in_progress"
+  }).returning({
+    id: schema.aiSessions.id,
+    ticketId: schema.aiSessions.ticketId,
+    cursorSessionId: schema.aiSessions.cursorSessionId,
+    createdAt: schema.aiSessions.createdAt
+  });
+  if (!sessionData) {
+    throw new Error("Failed to create AI session");
+  }
+  const sessionId = `ai-sess-${sessionData.id.substring(0, 8)}`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F680} **AI Session Started!**
 
 \u{1F194} Session ID: **${sessionId}**
 \u{1F3AB} Ticket: ${ticketId}
@@ -1014,115 +1356,143 @@ ${complexityScore ? `\u{1F3AF} Complexity: ${complexityScore}/10
 ` : ""}\u{1F4C5} Started: ${sessionStartTime.toLocaleString()}
 
 \u{1F4DD} Timetrack entry will be created when you complete the session.`
-          }]
-        };
       }
-      case "track-manual-follow-up": {
-        const { aiSessionId, originalPrompt, aiResponse, developerFollowUp, followUpReason, outcome = "success", estimatedMinutes, workDescription } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: sessionError } = await supabase.from("ai_sessions").select("id, status, created_at, ai_time_estimate_minutes").in("team_id", teamIds);
-        if (sessionError) {
-          throw new Error(`Database error: ${sessionError.message}`);
-        }
-        const session = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!session) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        const followUpTime = /* @__PURE__ */ new Date();
-        const oldEstimate = session.ai_time_estimate_minutes || 60;
-        const roundedFollowUpMinutes = roundToNearest15Minutes(estimatedMinutes || 0);
-        const newEstimate = oldEstimate + roundedFollowUpMinutes;
-        await supabase.from("ai_sessions").update({
-          status: "in_progress",
-          // Restart active tracking
-          ai_time_estimate_minutes: newEstimate
-          // Increase estimate based on follow-up work
-          // Don't update completed_at - session continues
-        }).eq("id", session.id);
-        const { data, error } = await supabase.from("manual_follow_ups").insert({
-          ai_session_id: session.id,
-          developer_id: authContext.userId,
-          team_id: authContext.teamId,
-          original_prompt: originalPrompt,
-          ai_response: aiResponse,
-          follow_up_prompt: developerFollowUp,
-          follow_up_reason: followUpReason,
-          outcome,
-          time_spent_minutes: null,
-          // Calculated automatically from session timestamps
-          resolved_at: outcome === "success" ? (/* @__PURE__ */ new Date()).toISOString() : null
-        }).select().single();
-        if (error) throw error;
-        await supabase.from("ai_time_logs").insert({
-          ai_session_id: session.id,
-          activity_type: "debugging",
-          // Follow-ups are typically debugging/fixing
-          description: `Follow-up: ${followUpReason.replace("_", " ")} - ${outcome}`,
-          duration_seconds: 0,
-          // Duration calculated automatically from timestamps
-          productivity_score: outcome === "success" ? 9 : outcome === "partial_success" ? 6 : 4,
-          started_at: followUpTime.toISOString()
-        });
-        const sessionStartTime = new Date(session.created_at);
-        const totalMinutesElapsed = Math.round((followUpTime.getTime() - sessionStartTime.getTime()) / 6e4);
-        const currentEfficiency = totalMinutesElapsed > 0 ? totalMinutesElapsed / newEstimate : 1;
-        await supabase.from("ai_sessions").update({
-          efficiency_score: currentEfficiency.toFixed(2),
-          actual_time_minutes: totalMinutesElapsed
-        }).eq("id", session.id);
-        const { data: existingEntries, error: entryError } = await supabase.from("agenda_events").select("id, tracked_duration, title, description, start_time").eq("ai_session_id", session.id).eq("status", "draft").order("created_at", { ascending: false });
-        let trackerAction = "";
-        let trackerDetails = "";
-        const existingEntry = existingEntries && existingEntries.length > 0 ? existingEntries[0] : null;
-        if (existingEntries && existingEntries.length > 1) {
-          const totalExistingDuration = existingEntries.reduce((sum, entry) => sum + (entry.tracked_duration || 0), 0);
-          const duplicateIds = existingEntries.slice(1).map((e) => e.id);
-          await supabase.from("agenda_events").delete().in("id", duplicateIds);
-          if (totalExistingDuration > (existingEntry?.tracked_duration || 0)) {
-            await supabase.from("agenda_events").update({ tracked_duration: totalExistingDuration }).eq("id", existingEntry.id);
-            existingEntry.tracked_duration = totalExistingDuration;
-          }
-          trackerAction = `Consolidated ${existingEntries.length} duplicate entries`;
-        }
-        if (existingEntry) {
-          const newDuration = (existingEntry.tracked_duration || 0) + roundedFollowUpMinutes * 60;
-          await supabase.from("agenda_events").update({
-            tracked_duration: newDuration,
-            end_time: followUpTime.toISOString(),
-            title: workDescription,
-            description: workDescription
-          }).eq("id", existingEntry.id);
-          trackerAction = trackerAction || "Updated existing tracker";
-          trackerDetails = `   \u2022 Total tracked time: ${Math.round(newDuration / 60)} minutes (+${roundedFollowUpMinutes} min)
+    ]
+  };
+}
+async function handleTrackManualFollowUp(input) {
+  const ctx = authContext;
+  const {
+    aiSessionId,
+    originalPrompt,
+    aiResponse,
+    developerFollowUp,
+    followUpReason,
+    outcome = "success",
+    estimatedMinutes,
+    workDescription
+  } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) {
+    throw new Error(`Session not found: ${aiSessionId}`);
+  }
+  const [session] = await db.select({
+    id: schema.aiSessions.id,
+    status: schema.aiSessions.status,
+    createdAt: schema.aiSessions.createdAt,
+    aiTimeEstimateMinutes: schema.aiSessions.aiTimeEstimateMinutes
+  }).from(schema.aiSessions).where(eq(schema.aiSessions.id, fullSessionId)).limit(1);
+  if (!session) throw new Error(`Session not found: ${aiSessionId}`);
+  const followUpTime = /* @__PURE__ */ new Date();
+  const oldEstimate = session.aiTimeEstimateMinutes ?? 60;
+  const roundedFollowUpMinutes = roundToNearest15Minutes(
+    estimatedMinutes || 0
+  );
+  const newEstimate = oldEstimate + roundedFollowUpMinutes;
+  await db.update(schema.aiSessions).set({
+    status: "in_progress",
+    aiTimeEstimateMinutes: newEstimate
+  }).where(eq(schema.aiSessions.id, session.id));
+  await db.insert(schema.manualFollowUps).values({
+    aiSessionId: session.id,
+    developerId: ctx.userId,
+    teamId: ctx.teamId,
+    originalPrompt,
+    aiResponse,
+    followUpPrompt: developerFollowUp,
+    followUpReason,
+    outcome,
+    timeSpentMinutes: null,
+    resolvedAt: outcome === "success" ? (/* @__PURE__ */ new Date()).toISOString() : null
+  });
+  await db.insert(schema.aiTimeLogs).values({
+    aiSessionId: session.id,
+    activityType: "debugging",
+    description: `Follow-up: ${followUpReason.replace("_", " ")} - ${outcome}`,
+    durationSeconds: 0,
+    productivityScore: outcome === "success" ? 9 : outcome === "partial_success" ? 6 : 4,
+    startedAt: followUpTime.toISOString()
+  });
+  const sessionStartTime = new Date(session.createdAt);
+  const totalMinutesElapsed = Math.round(
+    (followUpTime.getTime() - sessionStartTime.getTime()) / 6e4
+  );
+  const currentEfficiency = totalMinutesElapsed > 0 ? totalMinutesElapsed / newEstimate : 1;
+  await db.update(schema.aiSessions).set({
+    efficiencyScore: currentEfficiency.toFixed(2),
+    actualTimeMinutes: totalMinutesElapsed
+  }).where(eq(schema.aiSessions.id, session.id));
+  const existingEntries = await db.select({
+    id: schema.agendaEvents.id,
+    trackedDuration: schema.agendaEvents.trackedDuration,
+    title: schema.agendaEvents.title,
+    description: schema.agendaEvents.description,
+    startTime: schema.agendaEvents.startTime
+  }).from(schema.agendaEvents).where(
+    and(
+      eq(schema.agendaEvents.aiSessionId, session.id),
+      eq(schema.agendaEvents.status, "draft")
+    )
+  ).orderBy(desc(schema.agendaEvents.createdAt));
+  let trackerAction = "";
+  let trackerDetails = "";
+  let existingEntry = existingEntries[0] ?? null;
+  if (existingEntries.length > 1) {
+    const totalExistingDuration = existingEntries.reduce(
+      (sum, entry) => sum + (entry.trackedDuration ?? 0),
+      0
+    );
+    const duplicateIds = existingEntries.slice(1).map((e) => e.id);
+    await db.delete(schema.agendaEvents).where(inArray(schema.agendaEvents.id, duplicateIds));
+    if (existingEntry && totalExistingDuration > (existingEntry.trackedDuration ?? 0)) {
+      await db.update(schema.agendaEvents).set({ trackedDuration: totalExistingDuration }).where(eq(schema.agendaEvents.id, existingEntry.id));
+      existingEntry = { ...existingEntry, trackedDuration: totalExistingDuration };
+    }
+    trackerAction = `Consolidated ${existingEntries.length} duplicate entries`;
+  }
+  if (existingEntry) {
+    const newDuration = (existingEntry.trackedDuration ?? 0) + roundedFollowUpMinutes * 60;
+    await db.update(schema.agendaEvents).set({
+      trackedDuration: newDuration,
+      endTime: followUpTime.toISOString(),
+      title: workDescription,
+      description: workDescription
+    }).where(eq(schema.agendaEvents.id, existingEntry.id));
+    trackerAction = trackerAction || "Updated existing tracker";
+    trackerDetails = `   \u2022 Total tracked time: ${Math.round(newDuration / 60)} minutes (+${roundedFollowUpMinutes} min)
    \u2022 Description: ${workDescription}
 `;
-        } else {
-          const durationSeconds = roundedFollowUpMinutes * 60;
-          const startTime = new Date(followUpTime.getTime() - durationSeconds * 1e3);
-          await supabase.from("agenda_events").insert({
-            team_id: authContext.teamId,
-            user_id: authContext.userId,
-            ai_session_id: session.id,
-            title: workDescription,
-            description: workDescription,
-            start_time: startTime.toISOString(),
-            end_time: followUpTime.toISOString(),
-            type: "work",
-            status: "draft",
-            all_day: false,
-            is_tracked: true,
-            tracked_duration: durationSeconds
-          });
-          trackerAction = "Created new tracker";
-          trackerDetails = `   \u2022 Tracked time: ${roundedFollowUpMinutes} minutes
+  } else {
+    const durationSeconds = roundedFollowUpMinutes * 60;
+    const startTime = new Date(
+      followUpTime.getTime() - durationSeconds * 1e3
+    );
+    await db.insert(schema.agendaEvents).values({
+      teamId: ctx.teamId,
+      userId: ctx.userId,
+      aiSessionId: session.id,
+      title: workDescription,
+      description: workDescription,
+      startTime: startTime.toISOString(),
+      endTime: followUpTime.toISOString(),
+      type: "work",
+      status: "draft",
+      allDay: false,
+      isTracked: true,
+      trackedDuration: durationSeconds
+    });
+    trackerAction = "Created new tracker";
+    trackerDetails = `   \u2022 Tracked time: ${roundedFollowUpMinutes} minutes
    \u2022 Description: ${workDescription}
 `;
-        }
-        return {
-          content: [{
-            type: "text",
-            text: `\u{1F504} **Follow-up Tracked & Session Restarted!**
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F504} **Follow-up Tracked & Session Restarted!**
 
 \u{1F194} Session: ${aiSessionId} (back to active)
 \u{1F50D} Reason: ${followUpReason.replace("_", " ")}
@@ -1140,197 +1510,222 @@ ${complexityScore ? `\u{1F3AF} Complexity: ${complexityScore}/10
 \u23F1\uFE0F **Tracker Entry: ${trackerAction}**
 ` + trackerDetails + `
 \u26A1 **Time tracking resumed** - continue with confidence!`
-          }]
-        };
       }
-      case "get-session-context": {
-        const { aiSessionId, includeTicketData = true, includeTodoProgress = true, includeFollowUpHistory = false } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: sessionError } = await supabase.from("ai_sessions").select(`
-            id,
-            ticket_id,
-            status,
-            ai_time_estimate_minutes,
-            actual_time_minutes,
-            complexity_score,
-            created_at,
-            cursor_session_id
-          `).in("team_id", teamIds);
-        if (sessionError) {
-          throw new Error(`Database error: ${sessionError.message}`);
-        }
-        const session = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (sessionError || !session) {
-          throw new Error(`Session not found: ${aiSessionId}`);
-        }
-        let context = {
-          sessionId: aiSessionId,
-          status: session.status,
-          timeEstimate: session.ai_time_estimate_minutes,
-          actualTime: session.actual_time_minutes,
-          complexity: session.complexity_score,
-          createdAt: session.created_at
-        };
-        if (includeTicketData) {
-          const { data: ticket } = await supabase.from("tickets").select("id, ticket_number, title, description, status, priority, type").eq("id", session.ticket_id).single();
-          context.ticketData = ticket;
-        }
-        if (includeTodoProgress) {
-          const { data: todos } = await supabase.from("ai_todos").select("id, content, status, estimated_minutes, actual_minutes").eq("ai_session_id", session.id).order("sequence_order");
-          context.todos = todos || [];
-          context.todoProgress = {
-            total: todos?.length || 0,
-            completed: todos?.filter((t) => t.status === "completed").length || 0,
-            inProgress: todos?.filter((t) => t.status === "in_progress").length || 0
-          };
-        }
-        if (includeFollowUpHistory) {
-          const { data: followUps } = await supabase.from("manual_follow_ups").select("follow_up_reason, outcome, time_spent_minutes, created_at").eq("ai_session_id", session.id).order("created_at");
-          context.followUpHistory = followUps || [];
-        }
-        return {
-          content: [{
-            type: "text",
-            text: `\u{1F3AF} **Session Context Retrieved**
+    ]
+  };
+}
+async function handleGetSessionContext(input) {
+  const ctx = authContext;
+  const {
+    aiSessionId,
+    includeTicketData = true,
+    includeTodoProgress = true,
+    includeFollowUpHistory = false
+  } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  const [session] = await db.select({
+    id: schema.aiSessions.id,
+    ticketId: schema.aiSessions.ticketId,
+    status: schema.aiSessions.status,
+    aiTimeEstimateMinutes: schema.aiSessions.aiTimeEstimateMinutes,
+    actualTimeMinutes: schema.aiSessions.actualTimeMinutes,
+    complexityScore: schema.aiSessions.complexityScore,
+    createdAt: schema.aiSessions.createdAt,
+    cursorSessionId: schema.aiSessions.cursorSessionId
+  }).from(schema.aiSessions).where(eq(schema.aiSessions.id, fullSessionId)).limit(1);
+  if (!session) throw new Error(`Session not found: ${aiSessionId}`);
+  const context = {
+    status: session.status,
+    timeEstimate: session.aiTimeEstimateMinutes,
+    actualTime: session.actualTimeMinutes,
+    complexity: session.complexityScore,
+    createdAt: session.createdAt
+  };
+  if (includeTicketData) {
+    const [ticket] = await db.select({
+      id: schema.tickets.id,
+      ticketNumber: schema.tickets.ticketNumber,
+      title: schema.tickets.title,
+      description: schema.tickets.description,
+      status: schema.tickets.status,
+      priority: schema.tickets.priority,
+      type: schema.tickets.type
+    }).from(schema.tickets).where(eq(schema.tickets.id, session.ticketId)).limit(1);
+    context.ticketData = ticket ?? null;
+  }
+  if (includeTodoProgress) {
+    const todos = await db.select({
+      id: schema.aiTodos.id,
+      content: schema.aiTodos.content,
+      status: schema.aiTodos.status,
+      estimatedMinutes: schema.aiTodos.estimatedMinutes,
+      actualMinutes: schema.aiTodos.actualMinutes
+    }).from(schema.aiTodos).where(eq(schema.aiTodos.aiSessionId, session.id)).orderBy(asc(schema.aiTodos.sequenceOrder));
+    context.todos = todos;
+    context.todoProgress = {
+      total: todos.length,
+      completed: todos.filter((t) => t.status === "completed").length,
+      inProgress: todos.filter((t) => t.status === "in_progress").length
+    };
+  }
+  if (includeFollowUpHistory) {
+    const followUps = await db.select({
+      followUpReason: schema.manualFollowUps.followUpReason,
+      outcome: schema.manualFollowUps.outcome,
+      timeSpentMinutes: schema.manualFollowUps.timeSpentMinutes,
+      createdAt: schema.manualFollowUps.createdAt
+    }).from(schema.manualFollowUps).where(eq(schema.manualFollowUps.aiSessionId, session.id)).orderBy(asc(schema.manualFollowUps.createdAt));
+    context.followUpHistory = followUps;
+  }
+  const ticketData = context.ticketData;
+  const todoProgress = context.todoProgress;
+  const followUpHistory = context.followUpHistory;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F3AF} **Session Context Retrieved**
 
 Session: ${aiSessionId}
 Status: ${session.status}
-${context.ticketData ? `Ticket: ${context.ticketData.ticket_number} - ${context.ticketData.title}
-` : ""}${context.todoProgress ? `Todo Progress: ${context.todoProgress.completed}/${context.todoProgress.total} completed
-` : ""}${context.followUpHistory ? `Follow-ups: ${context.followUpHistory.length}
+${ticketData ? `Ticket: ${ticketData.ticketNumber} - ${ticketData.title}
+` : ""}${todoProgress ? `Todo Progress: ${todoProgress.completed}/${todoProgress.total} completed
+` : ""}${followUpHistory ? `Follow-ups: ${followUpHistory.length}
 ` : ""}
 \u{1F4CB} Full context preserved for seamless continuation!`
-          }]
-        };
       }
-      case "sync-session-todos": {
-        const { aiSessionId, todos, replaceAll = true } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: sessionError } = await supabase.from("ai_sessions").select("id").in("team_id", teamIds);
-        if (sessionError) {
-          throw new Error(`Database error: ${sessionError.message}`);
-        }
-        const session = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!session) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        if (replaceAll) {
-          await supabase.from("ai_todos").delete().eq("ai_session_id", session.id);
-        }
-        if (todos && todos.length > 0) {
-          let startSequence = 0;
-          if (!replaceAll) {
-            const { data: maxTodo } = await supabase.from("ai_todos").select("sequence_order").eq("ai_session_id", session.id).order("sequence_order", { ascending: false }).limit(1).single();
-            startSequence = (maxTodo?.sequence_order || 0) + 1;
-          }
-          const todoInserts = todos.map((todo, index) => ({
-            ai_session_id: session.id,
-            content: todo.content,
-            status: todo.status,
-            cursor_todo_id: todo.todoId || null,
-            estimated_minutes: todo.estimatedMinutes || null,
-            sequence_order: startSequence + index
-          }));
-          const { error: insertError } = await supabase.from("ai_todos").insert(todoInserts);
-          if (insertError) throw insertError;
-        }
-        let phaseTransition = null;
-        const { data: currentTodos } = await supabase.from("ai_todos").select("status").eq("ai_session_id", session.id);
-        if (currentTodos && currentTodos.length > 0) {
-          const hasInProgress = currentTodos.some((t) => t.status === "in_progress");
-          const allCompleted = currentTodos.every((t) => t.status === "completed");
-          const { data: currentPhase } = await supabase.from("ai_time_logs").select("activity_type, status").eq("ai_session_id", session.id).eq("status", "in_progress").single();
-          if (hasInProgress && currentPhase?.activity_type === "analysis") {
-            await transitionToNextPhase(session.id, "analysis");
-            phaseTransition = "Analysis completed \u2192 Next phase started (Investigation/Development)";
-          }
-          if (hasInProgress && currentPhase?.activity_type === "bug_investigation") {
-            const completedCount = currentTodos.filter((t) => t.status === "completed").length;
-            if (completedCount > 0) {
-              await transitionToNextPhase(session.id, "bug_investigation");
-              phaseTransition = "Investigation completed \u2192 Development phase started";
-            }
-          }
-          if (allCompleted && currentPhase?.activity_type === "development") {
-            await transitionToNextPhase(session.id, "development");
-            phaseTransition = "Development completed \u2192 Communication phase started";
-          }
-        }
-        return {
-          content: [{
-            type: "text",
-            text: `\u2705 **Todos ${replaceAll ? "Synced" : "Added"} Successfully!**
+    ]
+  };
+}
+async function handleSyncSessionTodos(input) {
+  const ctx = authContext;
+  const { aiSessionId, todos, replaceAll = true } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  if (replaceAll) {
+    await db.delete(schema.aiTodos).where(eq(schema.aiTodos.aiSessionId, fullSessionId));
+  }
+  if (todos && todos.length > 0) {
+    let startSequence = 0;
+    if (!replaceAll) {
+      const [maxTodo] = await db.select({ sequenceOrder: schema.aiTodos.sequenceOrder }).from(schema.aiTodos).where(eq(schema.aiTodos.aiSessionId, fullSessionId)).orderBy(desc(schema.aiTodos.sequenceOrder)).limit(1);
+      startSequence = (maxTodo?.sequenceOrder ?? 0) + 1;
+    }
+    await db.insert(schema.aiTodos).values(
+      todos.map((todo, index) => ({
+        aiSessionId: fullSessionId,
+        content: todo.content,
+        status: todo.status,
+        cursorTodoId: todo.todoId ?? null,
+        estimatedMinutes: todo.estimatedMinutes ?? null,
+        sequenceOrder: startSequence + index
+      }))
+    );
+  }
+  let phaseTransition = null;
+  const currentTodos = await db.select({ status: schema.aiTodos.status }).from(schema.aiTodos).where(eq(schema.aiTodos.aiSessionId, fullSessionId));
+  if (currentTodos.length > 0) {
+    const hasInProgress = currentTodos.some((t) => t.status === "in_progress");
+    const allCompleted = currentTodos.every((t) => t.status === "completed");
+    const [currentPhase] = await db.select({
+      activityType: schema.aiTimeLogs.activityType,
+      status: schema.aiTimeLogs.status
+    }).from(schema.aiTimeLogs).where(
+      and(
+        eq(schema.aiTimeLogs.aiSessionId, fullSessionId),
+        eq(schema.aiTimeLogs.status, "in_progress")
+      )
+    ).limit(1);
+    if (hasInProgress && currentPhase?.activityType === "analysis") {
+      await transitionToNextPhase(fullSessionId, "analysis");
+      phaseTransition = "Analysis completed \u2192 Next phase started (Investigation/Development)";
+    }
+    if (hasInProgress && currentPhase?.activityType === "bug_investigation") {
+      const completedCount = currentTodos.filter(
+        (t) => t.status === "completed"
+      ).length;
+      if (completedCount > 0) {
+        await transitionToNextPhase(fullSessionId, "bug_investigation");
+        phaseTransition = "Investigation completed \u2192 Development phase started";
+      }
+    }
+    if (allCompleted && currentPhase?.activityType === "development") {
+      await transitionToNextPhase(fullSessionId, "development");
+      phaseTransition = "Development completed \u2192 Communication phase started";
+    }
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Todos ${replaceAll ? "Synced" : "Added"} Successfully!**
 
 Session: ${aiSessionId}
 ${replaceAll ? "Synced" : "Added"} ${todos?.length || 0} todos
 ${replaceAll ? "" : "\u2795 Added to existing todo list\n"}${phaseTransition ? `\u{1F504} Phase Transition: ${phaseTransition}
 ` : ""}
 \u{1F4DD} Todo list updated and tracked for progress monitoring!`
-          }]
-        };
       }
-      case "add-follow-up-todos": {
-        const { aiSessionId, newTodos, followUpReason } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: sessionError } = await supabase.from("ai_sessions").select("id").in("team_id", teamIds);
-        if (sessionError) {
-          throw new Error(`Database error: ${sessionError.message}`);
-        }
-        const session = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!session) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        if (newTodos && newTodos.length > 0) {
-          const { data: maxTodo } = await supabase.from("ai_todos").select("sequence_order").eq("ai_session_id", session.id).order("sequence_order", { ascending: false }).limit(1).single();
-          const startSequence = (maxTodo?.sequence_order || 0) + 1;
-          const todoInserts = newTodos.map((todo, index) => ({
-            ai_session_id: session.id,
-            content: `[Follow-up] ${todo.content}`,
-            status: todo.status || "pending",
-            estimated_minutes: todo.estimatedMinutes || null,
-            sequence_order: startSequence + index
-          }));
-          const { error: insertError } = await supabase.from("ai_todos").insert(todoInserts);
-          if (insertError) throw insertError;
-        }
-        return {
-          content: [{
-            type: "text",
-            text: `\u2705 **Follow-up Todos Added Successfully!**
+    ]
+  };
+}
+async function handleAddFollowUpTodos(input) {
+  const ctx = authContext;
+  const { aiSessionId, newTodos, followUpReason } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  if (newTodos && newTodos.length > 0) {
+    const [maxTodo] = await db.select({ sequenceOrder: schema.aiTodos.sequenceOrder }).from(schema.aiTodos).where(eq(schema.aiTodos.aiSessionId, fullSessionId)).orderBy(desc(schema.aiTodos.sequenceOrder)).limit(1);
+    const startSequence = (maxTodo?.sequenceOrder ?? 0) + 1;
+    await db.insert(schema.aiTodos).values(
+      newTodos.map((todo, index) => ({
+        aiSessionId: fullSessionId,
+        content: `[Follow-up] ${todo.content}`,
+        status: todo.status ?? "pending",
+        estimatedMinutes: todo.estimatedMinutes ?? null,
+        sequenceOrder: startSequence + index
+      }))
+    );
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Follow-up Todos Added Successfully!**
 
 Session: ${aiSessionId}
 Added ${newTodos?.length || 0} new todos from follow-up
 ${followUpReason ? `Reason: ${followUpReason}
 ` : ""}
 \u{1F4DD} New tasks identified and added to existing workflow!`
-          }]
-        };
       }
-      case "update-session-status": {
-        const { aiSessionId, status, actualTimeMinutes, completionNotes } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: findError } = await supabase.from("ai_sessions").select("id").in("team_id", teamIds);
-        if (findError) {
-          throw new Error(`Database error: ${findError.message}`);
-        }
-        const foundSession = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!foundSession) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        const { data, error } = await supabase.from("ai_sessions").update({
-          status,
-          actual_time_minutes: actualTimeMinutes || null,
-          completed_at: status === "completed" ? (/* @__PURE__ */ new Date()).toISOString() : null
-        }).eq("id", foundSession.id).select().single();
-        if (error) throw error;
-        return {
-          content: [{
-            type: "text",
-            text: `\u{1F3AF} **Session Status Updated!**
+    ]
+  };
+}
+async function handleUpdateSessionStatus(input) {
+  const ctx = authContext;
+  const { aiSessionId, status, actualTimeMinutes, completionNotes } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  await db.update(schema.aiSessions).set({
+    status,
+    actualTimeMinutes: actualTimeMinutes ?? null,
+    completedAt: status === "completed" ? (/* @__PURE__ */ new Date()).toISOString() : null
+  }).where(eq(schema.aiSessions.id, fullSessionId));
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F3AF} **Session Status Updated!**
 
 Session: ${aiSessionId}
 Status: ${status}
@@ -1338,113 +1733,135 @@ ${actualTimeMinutes ? `Actual Time: ${actualTimeMinutes} minutes
 ` : ""}${status === "completed" ? `\u2705 Session completed successfully!
 ` : ""}${completionNotes ? `Notes: ${completionNotes}
 ` : ""}`
-          }]
-        };
       }
-      case "get-completion-context": {
-        const { aiSessionId, includeFollowUps = true, includeTimeMetrics = true, includeTodos = true } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: sessionError } = await supabase.from("ai_sessions").select(`
-            id,
-            ticket_id,
-            ai_time_estimate_minutes,
-            actual_time_minutes,
-            efficiency_score,
-            created_at,
-            completed_at,
-            status,
-            complexity_score
-          `).in("team_id", teamIds);
-        if (sessionError) {
-          throw new Error(`Database error: ${sessionError.message}`);
-        }
-        const session = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!session) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        const { data: ticket, error: ticketError } = await supabase.from("tickets").select("ticket_number, title, description, type, priority").eq("id", session.ticket_id).single();
-        if (ticketError || !ticket) {
-          throw new Error("Ticket not found for session");
-        }
-        let contextData = {
-          session: {
-            id: aiSessionId,
-            status: session.status,
-            complexity: session.complexity_score,
-            createdAt: session.created_at,
-            completedAt: session.completed_at
-          },
-          ticket: {
-            number: ticket.ticket_number,
-            title: ticket.title,
-            description: ticket.description,
-            type: ticket.type,
-            priority: ticket.priority
-          }
-        };
-        if (includeTimeMetrics) {
-          const timeSaved = session.ai_time_estimate_minutes && session.actual_time_minutes ? Math.max(0, session.ai_time_estimate_minutes - session.actual_time_minutes) : null;
-          contextData.timeMetrics = {
-            estimatedMinutes: session.ai_time_estimate_minutes,
-            actualMinutes: session.actual_time_minutes,
-            timeSaved,
-            efficiency: session.efficiency_score,
-            sessionDuration: session.completed_at && session.created_at ? Math.round((new Date(session.completed_at).getTime() - new Date(session.created_at).getTime()) / 6e4) : null
-          };
-        }
-        if (includeTodos) {
-          const { data: todos } = await supabase.from("ai_todos").select("content, status, estimated_minutes, actual_minutes, completed_at").eq("ai_session_id", session.id).order("created_at", { ascending: true });
-          contextData.todos = todos || [];
-        }
-        if (includeFollowUps) {
-          const { data: followUps } = await supabase.from("manual_follow_ups").select("follow_up_reason, outcome, time_spent_minutes, created_at").eq("ai_session_id", session.id).order("created_at", { ascending: true });
-          contextData.followUps = followUps || [];
-        }
-        return {
-          content: [{
-            type: "text",
-            text: `\u{1F4CB} **Completion Context Retrieved!**
+    ]
+  };
+}
+async function handleGetCompletionContext(input) {
+  const ctx = authContext;
+  const {
+    aiSessionId,
+    includeFollowUps = true,
+    includeTimeMetrics = true,
+    includeTodos = true
+  } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  const [session] = await db.select({
+    id: schema.aiSessions.id,
+    ticketId: schema.aiSessions.ticketId,
+    aiTimeEstimateMinutes: schema.aiSessions.aiTimeEstimateMinutes,
+    actualTimeMinutes: schema.aiSessions.actualTimeMinutes,
+    efficiencyScore: schema.aiSessions.efficiencyScore,
+    createdAt: schema.aiSessions.createdAt,
+    completedAt: schema.aiSessions.completedAt,
+    status: schema.aiSessions.status,
+    complexityScore: schema.aiSessions.complexityScore
+  }).from(schema.aiSessions).where(eq(schema.aiSessions.id, fullSessionId)).limit(1);
+  if (!session) throw new Error(`Session not found: ${aiSessionId}`);
+  const [ticket] = await db.select({
+    ticketNumber: schema.tickets.ticketNumber,
+    title: schema.tickets.title,
+    description: schema.tickets.description,
+    type: schema.tickets.type,
+    priority: schema.tickets.priority
+  }).from(schema.tickets).where(eq(schema.tickets.id, session.ticketId)).limit(1);
+  if (!ticket) throw new Error("Ticket not found for session");
+  const contextData = {
+    session: {
+      id: aiSessionId,
+      status: session.status,
+      complexity: session.complexityScore,
+      createdAt: session.createdAt,
+      completedAt: session.completedAt
+    },
+    ticket: {
+      number: ticket.ticketNumber,
+      title: ticket.title,
+      description: ticket.description,
+      type: ticket.type,
+      priority: ticket.priority
+    }
+  };
+  if (includeTimeMetrics) {
+    const timeSaved = session.aiTimeEstimateMinutes && session.actualTimeMinutes ? Math.max(
+      0,
+      session.aiTimeEstimateMinutes - session.actualTimeMinutes
+    ) : null;
+    contextData.timeMetrics = {
+      estimatedMinutes: session.aiTimeEstimateMinutes,
+      actualMinutes: session.actualTimeMinutes,
+      timeSaved,
+      efficiency: session.efficiencyScore,
+      sessionDuration: session.completedAt && session.createdAt ? Math.round(
+        (new Date(session.completedAt).getTime() - new Date(session.createdAt).getTime()) / 6e4
+      ) : null
+    };
+  }
+  if (includeTodos) {
+    const todos = await db.select({
+      content: schema.aiTodos.content,
+      status: schema.aiTodos.status,
+      estimatedMinutes: schema.aiTodos.estimatedMinutes,
+      actualMinutes: schema.aiTodos.actualMinutes,
+      completedAt: schema.aiTodos.completedAt
+    }).from(schema.aiTodos).where(eq(schema.aiTodos.aiSessionId, session.id)).orderBy(asc(schema.aiTodos.createdAt));
+    contextData.todos = todos;
+  }
+  if (includeFollowUps) {
+    const followUps = await db.select({
+      followUpReason: schema.manualFollowUps.followUpReason,
+      outcome: schema.manualFollowUps.outcome,
+      timeSpentMinutes: schema.manualFollowUps.timeSpentMinutes,
+      createdAt: schema.manualFollowUps.createdAt
+    }).from(schema.manualFollowUps).where(eq(schema.manualFollowUps.aiSessionId, session.id)).orderBy(asc(schema.manualFollowUps.createdAt));
+    contextData.followUps = followUps;
+  }
+  const todosLen = contextData.todos ?? [];
+  const completedTodos = todosLen.filter((t) => t.status === "completed").length;
+  const followUpsLen = contextData.followUps?.length ?? 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F4CB} **Completion Context Retrieved!**
 
-\u{1F3AB} **Ticket:** ${ticket.ticket_number} - ${ticket.title}
+\u{1F3AB} **Ticket:** ${ticket.ticketNumber} - ${ticket.title}
 \u{1F194} **Session:** ${aiSessionId} (${session.status})
-\u23F1\uFE0F **Time:** ${session.actual_time_minutes || "N/A"}/${session.ai_time_estimate_minutes || "N/A"} minutes
-\u{1F4CB} **Todos:** ${contextData.todos?.filter((t) => t.status === "completed").length || 0}/${contextData.todos?.length || 0} completed
-\u{1F504} **Follow-ups:** ${contextData.followUps?.length || 0}
+\u23F1\uFE0F **Time:** ${session.actualTimeMinutes || "N/A"}/${session.aiTimeEstimateMinutes || "N/A"} minutes
+\u{1F4CB} **Todos:** ${completedTodos}/${todosLen.length} completed
+\u{1F504} **Follow-ups:** ${followUpsLen}
 
 \u2705 **Full context ready for Cursor AI to generate customer response!**
 
 **Context Data:**
 \`\`\`json
 ${JSON.stringify(contextData, null, 2)}\`\`\``
-          }]
-        };
       }
-      case "save-customer-response": {
-        const { aiSessionId, customerResponse, responseType = "completion" } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: sessionError } = await supabase.from("ai_sessions").select("id").in("team_id", teamIds);
-        if (sessionError) {
-          throw new Error(`Database error: ${sessionError.message}`);
-        }
-        const session = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!session) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        const { data: responseData, error: responseError } = await supabase.from("ai_responses").insert({
-          ai_session_id: session.id,
-          response_type: responseType,
-          content: customerResponse,
-          is_ready_for_customer: true,
-          provider_approved: false
-          // Needs manual approval
-        }).select().single();
-        if (responseError) throw responseError;
-        return {
-          content: [{
-            type: "text",
-            text: `\u{1F4BE} **Customer Response Saved!**
+    ]
+  };
+}
+async function handleSaveCustomerResponse(input) {
+  const ctx = authContext;
+  const { aiSessionId, customerResponse, responseType = "completion" } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  await db.insert(schema.aiResponses).values({
+    aiSessionId: fullSessionId,
+    responseType,
+    content: customerResponse,
+    isReadyForCustomer: true,
+    providerApproved: false
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F4BE} **Customer Response Saved!**
 
 \u{1F194} Session: ${aiSessionId}
 \u{1F4DD} Response Type: ${responseType}
@@ -1456,623 +1873,693 @@ ${JSON.stringify(contextData, null, 2)}\`\`\``
 **Preview:**
 \`\`\`
 ${customerResponse.substring(0, 200)}${customerResponse.length > 200 ? "..." : ""}\`\`\``
-          }]
-        };
       }
-      case "complete-ai-session": {
-        const { aiSessionId, workCompleted, technicalSummary, invoiceDescription, efficiencyNotes } = args2;
-        const sessionUuid = aiSessionId.replace("ai-sess-", "");
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const { data: allSessions, error: getSessionError } = await supabase.from("ai_sessions").select("id, ticket_id, ai_time_estimate_minutes, created_at").in("team_id", teamIds);
-        if (getSessionError) {
-          throw new Error(`Database error: ${getSessionError.message}`);
-        }
-        const existingSession = allSessions?.find((s) => s.id.toString().startsWith(sessionUuid));
-        if (!existingSession) {
-          throw new Error(`Session not found: ${aiSessionId} (searched ${allSessions?.length || 0} sessions)`);
-        }
-        const completionTime = /* @__PURE__ */ new Date();
-        const sessionStartTime = new Date(existingSession.created_at);
-        const timeSpentMinutes = Math.round((completionTime.getTime() - sessionStartTime.getTime()) / 6e4);
-        const { data: session, error: sessionError } = await supabase.from("ai_sessions").update({
-          status: "completed",
-          actual_time_minutes: timeSpentMinutes,
-          completed_at: completionTime.toISOString(),
-          efficiency_score: null
-          // Will be calculated
-        }).eq("id", existingSession.id).select("id, ticket_id, ai_time_estimate_minutes, created_at").single();
-        if (sessionError || !session) {
-          throw new Error(`Failed to update session: ${aiSessionId}`);
-        }
-        const efficiencyScore = session.ai_time_estimate_minutes ? timeSpentMinutes / session.ai_time_estimate_minutes : 1;
-        await supabase.from("ai_sessions").update({ efficiency_score: efficiencyScore.toFixed(2) }).eq("id", session.id);
-        const { data: activePhases } = await supabase.from("ai_time_logs").select("*").eq("ai_session_id", existingSession.id).eq("status", "in_progress");
-        for (const phase of activePhases || []) {
-          const duration = Math.round(
-            (completionTime.getTime() - new Date(phase.started_at).getTime()) / 1e3
-          );
-          await supabase.from("ai_time_logs").update({
-            ended_at: completionTime.toISOString(),
-            duration_seconds: duration,
-            status: "completed"
-          }).eq("id", phase.id);
-        }
-        await supabase.from("ai_time_logs").update({ status: "skipped" }).eq("ai_session_id", existingSession.id).eq("status", "pending").eq("estimated_duration_seconds", 0);
-        const sessionDuration = Math.round(
-          (completionTime.getTime() - new Date(session.created_at).getTime()) / 6e4
-        );
-        const workSummary = `Completed ${workCompleted.length} tasks including: ${workCompleted.slice(0, 3).join(", ")}${workCompleted.length > 3 ? " and more" : ""}.`;
-        const { data: ticketInfo } = await supabase.from("tickets").select("ticket_number, title, project_id").eq("id", session.ticket_id).single();
-        let completionDescription;
-        if (invoiceDescription) {
-          completionDescription = `${ticketInfo?.ticket_number || "Ticket"}: ${invoiceDescription}`;
-        } else {
-          const workDescription = workCompleted.map((task, index) => `${index + 1}. ${task}`).join("\n");
-          completionDescription = `${ticketInfo?.ticket_number || "Ticket"}: ${technicalSummary || workSummary}
+    ]
+  };
+}
+async function handleCompleteAiSession(input) {
+  const ctx = authContext;
+  const {
+    aiSessionId,
+    workCompleted,
+    technicalSummary,
+    invoiceDescription,
+    efficiencyNotes
+  } = input;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const teamIds = await getAccessibleTeamIds(ctx.teamId);
+  const fullSessionId = await resolveAiSessionId(prefix, teamIds);
+  if (!fullSessionId) throw new Error(`Session not found: ${aiSessionId}`);
+  const [existingSession] = await db.select({
+    id: schema.aiSessions.id,
+    ticketId: schema.aiSessions.ticketId,
+    aiTimeEstimateMinutes: schema.aiSessions.aiTimeEstimateMinutes,
+    createdAt: schema.aiSessions.createdAt
+  }).from(schema.aiSessions).where(eq(schema.aiSessions.id, fullSessionId)).limit(1);
+  if (!existingSession) {
+    throw new Error(`Session not found: ${aiSessionId}`);
+  }
+  const completionTime = /* @__PURE__ */ new Date();
+  const sessionStartTime = new Date(existingSession.createdAt);
+  const timeSpentMinutes = Math.round(
+    (completionTime.getTime() - sessionStartTime.getTime()) / 6e4
+  );
+  const [session] = await db.update(schema.aiSessions).set({
+    status: "completed",
+    actualTimeMinutes: timeSpentMinutes,
+    completedAt: completionTime.toISOString(),
+    efficiencyScore: null
+  }).where(eq(schema.aiSessions.id, existingSession.id)).returning({
+    id: schema.aiSessions.id,
+    ticketId: schema.aiSessions.ticketId,
+    aiTimeEstimateMinutes: schema.aiSessions.aiTimeEstimateMinutes,
+    createdAt: schema.aiSessions.createdAt
+  });
+  if (!session) throw new Error(`Failed to update session: ${aiSessionId}`);
+  const efficiencyScore = session.aiTimeEstimateMinutes ? timeSpentMinutes / session.aiTimeEstimateMinutes : 1;
+  await db.update(schema.aiSessions).set({ efficiencyScore: efficiencyScore.toFixed(2) }).where(eq(schema.aiSessions.id, session.id));
+  const activePhases = await db.select().from(schema.aiTimeLogs).where(
+    and(
+      eq(schema.aiTimeLogs.aiSessionId, existingSession.id),
+      eq(schema.aiTimeLogs.status, "in_progress")
+    )
+  );
+  for (const phase of activePhases) {
+    const duration = Math.round(
+      (completionTime.getTime() - new Date(phase.startedAt).getTime()) / 1e3
+    );
+    await db.update(schema.aiTimeLogs).set({
+      endedAt: completionTime.toISOString(),
+      durationSeconds: duration,
+      status: "completed"
+    }).where(eq(schema.aiTimeLogs.id, phase.id));
+  }
+  await db.update(schema.aiTimeLogs).set({ status: "skipped" }).where(
+    and(
+      eq(schema.aiTimeLogs.aiSessionId, existingSession.id),
+      eq(schema.aiTimeLogs.status, "pending"),
+      eq(schema.aiTimeLogs.estimatedDurationSeconds, 0)
+    )
+  );
+  const sessionDuration = Math.round(
+    (completionTime.getTime() - new Date(session.createdAt).getTime()) / 6e4
+  );
+  const workSummary = `Completed ${workCompleted.length} tasks including: ${workCompleted.slice(0, 3).join(", ")}${workCompleted.length > 3 ? " and more" : ""}.`;
+  const [ticketInfo] = await db.select({
+    ticketNumber: schema.tickets.ticketNumber,
+    title: schema.tickets.title,
+    projectId: schema.tickets.projectId
+  }).from(schema.tickets).where(eq(schema.tickets.id, session.ticketId)).limit(1);
+  let completionDescription;
+  if (invoiceDescription) {
+    completionDescription = `${ticketInfo?.ticketNumber || "Ticket"}: ${invoiceDescription}`;
+  } else {
+    const workDescription = workCompleted.map((task, index) => `${index + 1}. ${task}`).join("\n");
+    completionDescription = `${ticketInfo?.ticketNumber || "Ticket"}: ${technicalSummary || workSummary}
 
 Completed work:
 ${workDescription}`;
-        }
-        const estimatedMinutes = session.ai_time_estimate_minutes || timeSpentMinutes;
-        const sessionStart = new Date(session.created_at);
-        const estimatedEnd = new Date(sessionStart.getTime() + estimatedMinutes * 6e4);
-        const { data: existingAgendaEntries } = await supabase.from("agenda_events").select("id, tracked_duration").eq("ai_session_id", session.id).eq("status", "draft").order("created_at", { ascending: false });
-        let agendaEvent = null;
-        let agendaError = null;
-        let wasUpdated = false;
-        let consolidatedCount = 0;
-        const existingAgendaEntry = existingAgendaEntries && existingAgendaEntries.length > 0 ? existingAgendaEntries[0] : null;
-        if (existingAgendaEntries && existingAgendaEntries.length > 1) {
-          const duplicateIds = existingAgendaEntries.slice(1).map((e) => e.id);
-          await supabase.from("agenda_events").delete().in("id", duplicateIds);
-          consolidatedCount = existingAgendaEntries.length - 1;
-        }
-        if (existingAgendaEntry) {
-          const { data: updated, error: updateError } = await supabase.from("agenda_events").update({
-            title: ticketInfo?.title || "Development Work",
-            description: completionDescription,
-            end_time: estimatedEnd.toISOString(),
-            project_id: ticketInfo?.project_id || null,
-            ticket_id: session.ticket_id,
-            tracked_duration: estimatedMinutes * 60
-            // Use AI estimate in seconds for billing
-          }).eq("id", existingAgendaEntry.id).select("id").single();
-          agendaEvent = updated;
-          agendaError = updateError;
-          wasUpdated = true;
-        } else {
-          const { data: created, error: createError } = await supabase.from("agenda_events").insert({
-            team_id: authContext.teamId,
-            user_id: authContext.userId,
-            title: ticketInfo?.title || "Development Work",
-            description: completionDescription,
-            start_time: sessionStart.toISOString(),
-            end_time: estimatedEnd.toISOString(),
-            project_id: ticketInfo?.project_id || null,
-            ticket_id: session.ticket_id,
-            ai_session_id: session.id,
-            // Use the actual UUID, not the readable ID
-            type: "work",
-            status: "draft",
-            // Mark as draft for manual approval
-            all_day: false,
-            is_tracked: true,
-            tracked_duration: estimatedMinutes * 60
-            // Use AI estimate in seconds for billing
-          }).select("id").single();
-          agendaEvent = created;
-          agendaError = createError;
-        }
-        if (agendaError) {
-          console.error(`\u26A0\uFE0F Failed to ${wasUpdated ? "update" : "create"} agenda event:`, agendaError);
-        }
-        if (consolidatedCount > 0) {
-          console.log(`\u{1F9F9} Cleaned up ${consolidatedCount} duplicate agenda entries for session ${aiSessionId}`);
-        }
-        let responseText = `\u{1F389} **AI Session Completed Successfully!**
+  }
+  const estimatedMinutes = session.aiTimeEstimateMinutes ?? timeSpentMinutes;
+  const sessionStart = new Date(session.createdAt);
+  const estimatedEnd = new Date(
+    sessionStart.getTime() + estimatedMinutes * 6e4
+  );
+  const existingAgendaEntries = await db.select({
+    id: schema.agendaEvents.id,
+    trackedDuration: schema.agendaEvents.trackedDuration
+  }).from(schema.agendaEvents).where(
+    and(
+      eq(schema.agendaEvents.aiSessionId, session.id),
+      eq(schema.agendaEvents.status, "draft")
+    )
+  ).orderBy(desc(schema.agendaEvents.createdAt));
+  let agendaEventId = null;
+  let wasUpdated = false;
+  let consolidatedCount = 0;
+  const existingAgendaEntry = existingAgendaEntries[0] ?? null;
+  if (existingAgendaEntries.length > 1) {
+    const duplicateIds = existingAgendaEntries.slice(1).map((e) => e.id);
+    await db.delete(schema.agendaEvents).where(inArray(schema.agendaEvents.id, duplicateIds));
+    consolidatedCount = existingAgendaEntries.length - 1;
+  }
+  try {
+    if (existingAgendaEntry) {
+      const [updated] = await db.update(schema.agendaEvents).set({
+        title: ticketInfo?.title || "Development Work",
+        description: completionDescription,
+        endTime: estimatedEnd.toISOString(),
+        projectId: ticketInfo?.projectId ?? null,
+        trackedDuration: estimatedMinutes * 60
+      }).where(eq(schema.agendaEvents.id, existingAgendaEntry.id)).returning({ id: schema.agendaEvents.id });
+      agendaEventId = updated?.id ?? null;
+      wasUpdated = true;
+    } else {
+      const [created] = await db.insert(schema.agendaEvents).values({
+        teamId: ctx.teamId,
+        userId: ctx.userId,
+        title: ticketInfo?.title || "Development Work",
+        description: completionDescription,
+        startTime: sessionStart.toISOString(),
+        endTime: estimatedEnd.toISOString(),
+        projectId: ticketInfo?.projectId ?? null,
+        aiSessionId: session.id,
+        type: "work",
+        status: "draft",
+        allDay: false,
+        isTracked: true,
+        trackedDuration: estimatedMinutes * 60
+      }).returning({ id: schema.agendaEvents.id });
+      agendaEventId = created?.id ?? null;
+    }
+    if (agendaEventId && session.ticketId) {
+      await db.insert(schema.agendaEventTickets).values({
+        agendaEventId,
+        ticketId: session.ticketId
+      }).onConflictDoNothing();
+    }
+  } catch (err) {
+    console.error(
+      `\u26A0\uFE0F Failed to ${wasUpdated ? "update" : "create"} agenda event:`,
+      err
+    );
+  }
+  if (consolidatedCount > 0) {
+    console.log(
+      `\u{1F9F9} Cleaned up ${consolidatedCount} duplicate agenda entries for session ${aiSessionId}`
+    );
+  }
+  let responseText = `\u{1F389} **AI Session Completed Successfully!**
 
 `;
-        responseText += `\u{1F194} Session: ${aiSessionId}
+  responseText += `\u{1F194} Session: ${aiSessionId}
 `;
-        responseText += `\u{1F4CA} **Performance Summary:**
+  responseText += `\u{1F4CA} **Performance Summary:**
 `;
-        responseText += `   \u2022 Tasks Completed: ${workCompleted.length}
+  responseText += `   \u2022 Tasks Completed: ${workCompleted.length}
 `;
-        responseText += `   \u2022 Time Spent: ${timeSpentMinutes} minutes
+  responseText += `   \u2022 Time Spent: ${timeSpentMinutes} minutes
 `;
-        responseText += `   \u2022 Estimated Time: ${session.ai_time_estimate_minutes || "N/A"} minutes
+  responseText += `   \u2022 Estimated Time: ${session.aiTimeEstimateMinutes || "N/A"} minutes
 `;
-        responseText += `   \u2022 Efficiency: ${efficiencyScore < 1 ? "\u{1F680}" : efficiencyScore > 1.5 ? "\u26A0\uFE0F" : "\u23F1\uFE0F"} ${(efficiencyScore * 100).toFixed(0)}%
+  responseText += `   \u2022 Efficiency: ${efficiencyScore < 1 ? "\u{1F680}" : efficiencyScore > 1.5 ? "\u26A0\uFE0F" : "\u23F1\uFE0F"} ${(efficiencyScore * 100).toFixed(0)}%
 `;
-        responseText += `   \u2022 Session Duration: ${sessionDuration} minutes
+  responseText += `   \u2022 Session Duration: ${sessionDuration} minutes
 
 `;
-        responseText += `\u2705 **Work Completed:**
+  responseText += `\u2705 **Work Completed:**
 `;
-        workCompleted.forEach((task, index) => {
-          responseText += `${index + 1}. ${task}
+  workCompleted.forEach((task, index) => {
+    responseText += `${index + 1}. ${task}
 `;
-        });
-        responseText += `
+  });
+  responseText += `
 `;
-        if (technicalSummary) {
-          responseText += `\u{1F527} **Technical Summary:**
+  if (technicalSummary) {
+    responseText += `\u{1F527} **Technical Summary:**
 ${technicalSummary}
 
 `;
-        }
-        if (efficiencyNotes) {
-          responseText += `\u{1F4C8} **Efficiency Notes:**
+  }
+  if (efficiencyNotes) {
+    responseText += `\u{1F4C8} **Efficiency Notes:**
 ${efficiencyNotes}
 
 `;
-        }
-        if (agendaEvent) {
-          responseText += `\u{1F4C5} **Timetrack Entry ${wasUpdated ? "Updated" : "Created"}:**
+  }
+  if (agendaEventId) {
+    responseText += `\u{1F4C5} **Timetrack Entry ${wasUpdated ? "Updated" : "Created"}:**
 `;
-          responseText += `   \u2022 Agenda event ${wasUpdated ? "updated with final" : "created with"} work summary
+    responseText += `   \u2022 Agenda event ${wasUpdated ? "updated with final" : "created with"} work summary
 `;
-          responseText += `   \u2022 Status: DRAFT (requires approval in agenda)
+    responseText += `   \u2022 Status: DRAFT (requires approval in agenda)
 `;
-          responseText += `   \u2022 Duration: ${estimatedMinutes} minutes
+    responseText += `   \u2022 Duration: ${estimatedMinutes} minutes
 `;
-          responseText += `   \u2022 Period: ${sessionStart.toLocaleString()} - ${completionTime.toLocaleString()}
+    responseText += `   \u2022 Period: ${sessionStart.toLocaleString()} - ${completionTime.toLocaleString()}
 
 `;
-        }
-        responseText += `\u{1F4CB} **Context for Customer Response:**
+  }
+  responseText += `\u{1F4CB} **Context for Customer Response:**
 `;
-        responseText += `   \u2022 Use "get-completion-context" to retrieve full context
+  responseText += `   \u2022 Use "get-completion-context" to retrieve full context
 `;
-        responseText += `   \u2022 Generate customer-friendly response based on completed work
+  responseText += `   \u2022 Generate customer-friendly response based on completed work
 `;
-        responseText += `   \u2022 Focus on business value and customer benefits
+  responseText += `   \u2022 Focus on business value and customer benefits
 
 `;
-        responseText += `\u{1F3AF} **Session archived successfully!**`;
-        return {
-          content: [{
-            type: "text",
-            text: responseText
-          }]
-        };
+  responseText += `\u{1F3AF} **Session archived successfully!**`;
+  return { content: [{ type: "text", text: responseText }] };
+}
+async function handleLogHours(input) {
+  const ctx = authContext;
+  const {
+    projectId,
+    ticketId,
+    aiSessionId,
+    workDescription,
+    estimatedHours,
+    chatContextSummary
+  } = input;
+  let project = null;
+  let ticket = null;
+  let aiSession = null;
+  if (projectId) {
+    const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
+    if (!projectIds.includes(projectId)) {
+      throw new Error(
+        `Project not found or no access: ${projectId}. Please call get-projects first to find the correct project.`
+      );
+    }
+    const [projectData] = await db.select({
+      id: schema.projects.id,
+      name: schema.projects.name,
+      teamId: schema.projects.teamId
+    }).from(schema.projects).where(eq(schema.projects.id, projectId)).limit(1);
+    if (!projectData) throw new Error(`Project not found: ${projectId}.`);
+    project = projectData;
+  }
+  if (ticketId) {
+    const [ticketData] = await db.select({
+      id: schema.tickets.id,
+      title: schema.tickets.title,
+      status: schema.tickets.status,
+      teamId: schema.tickets.teamId,
+      projectId: schema.tickets.projectId,
+      customerId: schema.tickets.customerId
+    }).from(schema.tickets).where(eq(schema.tickets.id, ticketId)).limit(1);
+    if (!ticketData) {
+      throw new Error(
+        `Ticket not found: ${ticketId}. Please call get-tickets first to find the correct ticket.`
+      );
+    }
+    let hasAccess = false;
+    const teamIds = await getAccessibleTeamIds(ctx.teamId);
+    if (teamIds.includes(ticketData.teamId)) hasAccess = true;
+    if (!hasAccess && ticketData.projectId) {
+      const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
+      if (projectIds.includes(ticketData.projectId)) hasAccess = true;
+    }
+    if (!hasAccess && ticketData.customerId) {
+      const customerIds = await getAccessibleCustomerIds(ctx.teamId);
+      if (customerIds.includes(ticketData.customerId)) hasAccess = true;
+    }
+    if (!hasAccess) {
+      throw new Error(
+        `No access to ticket: ${ticketId}. Please call get-tickets first to find the correct ticket.`
+      );
+    }
+    ticket = ticketData;
+  }
+  if (aiSessionId) {
+    const [sessionData] = await db.select({
+      id: schema.aiSessions.id,
+      ticketId: schema.aiSessions.ticketId,
+      status: schema.aiSessions.status
+    }).from(schema.aiSessions).where(eq(schema.aiSessions.id, aiSessionId)).limit(1);
+    if (!sessionData) throw new Error(`AI Session not found: ${aiSessionId}.`);
+    aiSession = sessionData;
+  }
+  const durationSeconds = Math.round(estimatedHours * 3600);
+  const now = /* @__PURE__ */ new Date();
+  let agendaEntry = null;
+  let wasUpdated = false;
+  let consolidatedCount = 0;
+  if (aiSession?.id || ticket?.id) {
+    let existingEntries = [];
+    if (aiSession?.id) {
+      existingEntries = await db.select({
+        id: schema.agendaEvents.id,
+        trackedDuration: schema.agendaEvents.trackedDuration,
+        projectId: schema.agendaEvents.projectId,
+        aiSessionId: schema.agendaEvents.aiSessionId
+      }).from(schema.agendaEvents).where(
+        and(
+          eq(schema.agendaEvents.status, "draft"),
+          eq(schema.agendaEvents.userId, ctx.userId),
+          eq(schema.agendaEvents.aiSessionId, aiSession.id)
+        )
+      ).orderBy(desc(schema.agendaEvents.createdAt));
+    } else if (ticket?.id) {
+      const linkedEvents = await db.select({
+        agendaEventId: schema.agendaEventTickets.agendaEventId
+      }).from(schema.agendaEventTickets).where(eq(schema.agendaEventTickets.ticketId, ticket.id));
+      const eventIds = linkedEvents.map((e) => e.agendaEventId);
+      if (eventIds.length > 0) {
+        existingEntries = await db.select({
+          id: schema.agendaEvents.id,
+          trackedDuration: schema.agendaEvents.trackedDuration,
+          projectId: schema.agendaEvents.projectId,
+          aiSessionId: schema.agendaEvents.aiSessionId
+        }).from(schema.agendaEvents).where(
+          and(
+            inArray(schema.agendaEvents.id, eventIds),
+            eq(schema.agendaEvents.status, "draft"),
+            eq(schema.agendaEvents.userId, ctx.userId)
+          )
+        ).orderBy(desc(schema.agendaEvents.createdAt));
       }
-      case "log-hours": {
-        const { projectId, ticketId, aiSessionId, workDescription, estimatedHours, chatContextSummary } = args2;
-        let project = null;
-        let ticket = null;
-        let aiSession = null;
-        if (projectId) {
-          const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-          if (!projectIds.includes(projectId)) {
-            throw new Error(`Project not found or no access: ${projectId}. Please call get-projects first to find the correct project.`);
-          }
-          const { data: projectData, error: projectError } = await supabase.from("projects").select("id, name, team_id").eq("id", projectId).single();
-          if (projectError || !projectData) {
-            throw new Error(`Project not found: ${projectId}.`);
-          }
-          project = projectData;
-        }
-        if (ticketId) {
-          const { data: ticketData, error: ticketError } = await supabase.from("tickets").select("id, title, status, team_id, project_id, customer_id").eq("id", ticketId).single();
-          if (ticketError || !ticketData) {
-            throw new Error(`Ticket not found: ${ticketId}. Please call get-tickets first to find the correct ticket.`);
-          }
-          let hasAccess = false;
-          const teamIds = await getAccessibleTeamIds(authContext.teamId);
-          if (teamIds.includes(ticketData.team_id)) {
-            hasAccess = true;
-          }
-          if (!hasAccess && ticketData.project_id) {
-            const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-            if (projectIds.includes(ticketData.project_id)) {
-              hasAccess = true;
-            }
-          }
-          if (!hasAccess && ticketData.customer_id) {
-            const customerIds = await getAccessibleCustomerIds(authContext.teamId);
-            if (customerIds.includes(ticketData.customer_id)) {
-              hasAccess = true;
-            }
-          }
-          if (!hasAccess) {
-            throw new Error(`No access to ticket: ${ticketId}. Please call get-tickets first to find the correct ticket.`);
-          }
-          ticket = ticketData;
-        }
-        if (aiSessionId) {
-          const { data: sessionData, error: sessionError } = await supabase.from("ai_dev_sessions").select("id, ticket_id, status").eq("id", aiSessionId).single();
-          if (sessionError || !sessionData) {
-            throw new Error(`AI Session not found: ${aiSessionId}.`);
-          }
-          aiSession = sessionData;
-        }
-        const durationSeconds = Math.round(estimatedHours * 3600);
-        const now = /* @__PURE__ */ new Date();
-        let agendaEntry = null;
-        let agendaError = null;
-        let wasUpdated = false;
-        let consolidatedCount = 0;
-        if (aiSession?.id || ticket?.id) {
-          let query = supabase.from("agenda_events").select("id, tracked_duration, project_id, ticket_id, ai_session_id").eq("status", "draft").eq("user_id", authContext.userId).order("created_at", { ascending: false });
-          if (aiSession?.id) {
-            query = query.eq("ai_session_id", aiSession.id);
-          } else if (ticket?.id) {
-            query = query.eq("ticket_id", ticket.id);
-          }
-          const { data: existingEntries } = await query;
-          if (existingEntries && existingEntries.length > 0) {
-            const existingEntry = existingEntries[0];
-            if (existingEntries.length > 1) {
-              const duplicateIds = existingEntries.slice(1).map((e) => e.id);
-              await supabase.from("agenda_events").delete().in("id", duplicateIds);
-              consolidatedCount = existingEntries.length - 1;
-            }
-            const newDuration = (existingEntry.tracked_duration || 0) + durationSeconds;
-            const { data: updated, error: updateError } = await supabase.from("agenda_events").update({
-              tracked_duration: newDuration,
-              end_time: now.toISOString(),
-              title: workDescription,
-              description: chatContextSummary || workDescription,
-              project_id: project?.id || existingEntry.project_id
-            }).eq("id", existingEntry.id).select("id, tracked_duration, project_id, ticket_id, ai_session_id").single();
-            agendaEntry = updated;
-            agendaError = updateError;
-            wasUpdated = true;
-          }
-        }
-        if (!agendaEntry) {
-          const startTime = new Date(now.getTime() - durationSeconds * 1e3);
-          const { data: created, error: createError } = await supabase.from("agenda_events").insert({
-            team_id: authContext.teamId,
-            user_id: authContext.userId,
-            project_id: project?.id || null,
-            ticket_id: ticket?.id || null,
-            ai_session_id: aiSession?.id || null,
-            title: workDescription,
-            description: chatContextSummary || workDescription,
-            start_time: startTime.toISOString(),
-            end_time: now.toISOString(),
-            type: "work",
-            status: "draft",
-            all_day: false,
-            is_tracked: true,
-            tracked_duration: durationSeconds
-          }).select("id, tracked_duration, project_id, ticket_id, ai_session_id").single();
-          agendaEntry = created;
-          agendaError = createError;
-        }
-        if (agendaError || !agendaEntry) {
-          throw new Error(`Failed to ${wasUpdated ? "update" : "create"} time entry: ${agendaError?.message || "Unknown error"}`);
-        }
-        let responseText = `\u23F1\uFE0F **Hours ${wasUpdated ? "Added to Existing Entry" : "Logged Successfully"}!**
+    }
+    if (existingEntries.length > 0) {
+      const existingEntry = existingEntries[0];
+      if (existingEntries.length > 1) {
+        const duplicateIds = existingEntries.slice(1).map((e) => e.id);
+        await db.delete(schema.agendaEvents).where(inArray(schema.agendaEvents.id, duplicateIds));
+        consolidatedCount = existingEntries.length - 1;
+      }
+      const newDuration = (existingEntry.trackedDuration ?? 0) + durationSeconds;
+      const [updated] = await db.update(schema.agendaEvents).set({
+        trackedDuration: newDuration,
+        endTime: now.toISOString(),
+        title: workDescription,
+        description: chatContextSummary ?? workDescription,
+        projectId: project?.id ?? existingEntry.projectId
+      }).where(eq(schema.agendaEvents.id, existingEntry.id)).returning({
+        id: schema.agendaEvents.id,
+        trackedDuration: schema.agendaEvents.trackedDuration,
+        projectId: schema.agendaEvents.projectId,
+        aiSessionId: schema.agendaEvents.aiSessionId
+      });
+      agendaEntry = updated ?? null;
+      wasUpdated = true;
+    }
+  }
+  if (!agendaEntry) {
+    const startTime = new Date(now.getTime() - durationSeconds * 1e3);
+    const [created] = await db.insert(schema.agendaEvents).values({
+      teamId: ctx.teamId,
+      userId: ctx.userId,
+      projectId: project?.id ?? null,
+      aiSessionId: aiSession?.id ?? null,
+      title: workDescription,
+      description: chatContextSummary ?? workDescription,
+      startTime: startTime.toISOString(),
+      endTime: now.toISOString(),
+      type: "work",
+      status: "draft",
+      allDay: false,
+      isTracked: true,
+      trackedDuration: durationSeconds
+    }).returning({
+      id: schema.agendaEvents.id,
+      trackedDuration: schema.agendaEvents.trackedDuration,
+      projectId: schema.agendaEvents.projectId,
+      aiSessionId: schema.agendaEvents.aiSessionId
+    });
+    agendaEntry = created ?? null;
+    if (agendaEntry && ticket?.id) {
+      await db.insert(schema.agendaEventTickets).values({ agendaEventId: agendaEntry.id, ticketId: ticket.id }).onConflictDoNothing();
+    }
+  }
+  if (!agendaEntry) {
+    throw new Error(
+      `Failed to ${wasUpdated ? "update" : "create"} time entry`
+    );
+  }
+  let responseText = `\u23F1\uFE0F **Hours ${wasUpdated ? "Added to Existing Entry" : "Logged Successfully"}!**
 
 `;
-        if (wasUpdated) {
-          responseText += `\u{1F504} **Updated existing draft entry** (avoiding duplicates)
+  if (wasUpdated) {
+    responseText += `\u{1F504} **Updated existing draft entry** (avoiding duplicates)
 `;
-          responseText += `   \u2022 New total: ${Math.round((agendaEntry.tracked_duration || 0) / 3600 * 10) / 10}h
+    responseText += `   \u2022 New total: ${Math.round((agendaEntry.trackedDuration ?? 0) / 3600 * 10) / 10}h
 
 `;
-        }
-        if (consolidatedCount > 0) {
-          responseText += `\u{1F9F9} **Cleaned up ${consolidatedCount} duplicate entries**
+  }
+  if (consolidatedCount > 0) {
+    responseText += `\u{1F9F9} **Cleaned up ${consolidatedCount} duplicate entries**
 
 `;
-        }
-        responseText += `\u{1F4CB} **Entry Details:**
+  }
+  responseText += `\u{1F4CB} **Entry Details:**
 `;
-        if (project) {
-          responseText += `   \u2022 Project: ${project.name}
+  responseText += `   \u2022 Project: ${project ? project.name : "(No project assigned)"}
 `;
-        } else {
-          responseText += `   \u2022 Project: (No project assigned)
+  if (ticket) responseText += `   \u2022 Ticket: ${ticket.title} (${ticket.status})
 `;
-        }
-        if (ticket) {
-          responseText += `   \u2022 Ticket: ${ticket.title} (${ticket.status})
+  if (aiSession)
+    responseText += `   \u2022 AI Session: ${aiSession.id} (${aiSession.status})
 `;
-        }
-        if (aiSession) {
-          responseText += `   \u2022 AI Session: ${aiSession.id} (${aiSession.status})
+  responseText += `   \u2022 Description: ${workDescription}
 `;
-        }
-        responseText += `   \u2022 Description: ${workDescription}
-`;
-        responseText += `   \u2022 ${wasUpdated ? "Added" : "Estimated"} Hours: ${estimatedHours}h (${Math.floor(estimatedHours)}h ${Math.round(estimatedHours % 1 * 60)}m)
+  responseText += `   \u2022 ${wasUpdated ? "Added" : "Estimated"} Hours: ${estimatedHours}h (${Math.floor(estimatedHours)}h ${Math.round(estimatedHours % 1 * 60)}m)
 `;
-        responseText += `   \u2022 Status: DRAFT (not billed yet)
+  responseText += `   \u2022 Status: DRAFT (not billed yet)
 `;
-        responseText += `   \u2022 Entry ID: ${agendaEntry.id}
+  responseText += `   \u2022 Entry ID: ${agendaEntry.id}
 
 `;
-        if (chatContextSummary) {
-          responseText += `\u{1F4CA} **Work Context:**
+  if (chatContextSummary) {
+    responseText += `\u{1F4CA} **Work Context:**
 `;
-          responseText += `${chatContextSummary.substring(0, 200)}${chatContextSummary.length > 200 ? "..." : ""}
+    responseText += `${chatContextSummary.substring(0, 200)}${chatContextSummary.length > 200 ? "..." : ""}
 
 `;
-        }
-        responseText += `\u2705 Time entry ${wasUpdated ? "updated" : "created"} and ready for review in the agenda!`;
-        return {
-          content: [{
+  }
+  responseText += `\u2705 Time entry ${wasUpdated ? "updated" : "created"} and ready for review in the agenda!`;
+  return { content: [{ type: "text", text: responseText }] };
+}
+async function handleGetGithubFile(input) {
+  const ctx = authContext;
+  const { projectId, filePath, ref } = input;
+  const githubInfo = await getGithubTokenForProject(projectId, ctx.teamId);
+  if (!githubInfo) {
+    return {
+      content: [
+        { type: "text", text: "\u274C GitHub not configured for this project." }
+      ]
+    };
+  }
+  try {
+    const octokit = new Octokit({ auth: githubInfo.token });
+    console.error(
+      `\u{1F4C4} Reading file: ${filePath} from ${githubInfo.repositoryFullName}`
+    );
+    const { data } = await octokit.rest.repos.getContent({
+      owner: githubInfo.owner,
+      repo: githubInfo.repo,
+      path: filePath,
+      ref
+    });
+    if (Array.isArray(data) || data.type !== "file") {
+      return {
+        content: [
+          {
             type: "text",
-            text: responseText
-          }]
-        };
-      }
-      // === GITHUB TOOLS ===
-      case "get-github-file": {
-        const { projectId, filePath, ref } = args2;
-        const githubInfo = await getGithubTokenForProject(projectId, authContext.teamId);
-        if (!githubInfo) {
-          return {
-            content: [{
-              type: "text",
-              text: "\u274C GitHub not configured for this project."
-            }]
-          };
-        }
-        try {
-          const octokit = new Octokit({ auth: githubInfo.token });
-          console.error(`\u{1F4C4} Reading file: ${filePath} from ${githubInfo.repositoryFullName}`);
-          const { data } = await octokit.rest.repos.getContent({
-            owner: githubInfo.owner,
-            repo: githubInfo.repo,
-            path: filePath,
-            ref
-          });
-          if (Array.isArray(data) || data.type !== "file") {
-            return {
-              content: [{
-                type: "text",
-                text: `\u274C "${filePath}" is not a file or contains multiple items.`
-              }]
-            };
+            text: `\u274C "${filePath}" is not a file or contains multiple items.`
           }
-          const content = Buffer.from(data.content, "base64").toString("utf-8");
-          let responseText = `\u{1F4C4} **File: ${filePath}**
+        ]
+      };
+    }
+    const content = Buffer.from(data.content, "base64").toString("utf-8");
+    let responseText = `\u{1F4C4} **File: ${filePath}**
 `;
-          responseText += `Repository: ${githubInfo.repositoryFullName}
+    responseText += `Repository: ${githubInfo.repositoryFullName}
 `;
-          responseText += `Size: ${data.size} bytes
+    responseText += `Size: ${data.size} bytes
 `;
-          responseText += `URL: ${data.html_url}
+    responseText += `URL: ${data.html_url}
 
 `;
-          responseText += `**Content:**
+    responseText += `**Content:**
 \`\`\`
 ${content}
 \`\`\``;
-          return {
-            content: [{
-              type: "text",
-              text: responseText
-            }]
-          };
-        } catch (error) {
-          console.error("GitHub get file error:", error);
-          if (error.status === 404) {
-            return {
-              content: [{
-                type: "text",
-                text: `\u274C File not found: ${filePath}`
-              }]
-            };
-          }
-          return {
-            content: [{
-              type: "text",
-              text: `\u274C Failed to read file: ${error.message || "Unknown error"}`
-            }]
-          };
-        }
-      }
-      case "list-github-directory": {
-        const { projectId, directoryPath, ref } = args2;
-        const githubInfo = await getGithubTokenForProject(projectId, authContext.teamId);
-        if (!githubInfo) {
-          return {
-            content: [{
-              type: "text",
-              text: "\u274C GitHub not configured for this project."
-            }]
-          };
-        }
-        try {
-          const octokit = new Octokit({ auth: githubInfo.token });
-          const normalizedPath = !directoryPath || directoryPath === "/" ? "" : directoryPath;
-          console.error(`\u{1F4C1} Listing directory: ${normalizedPath || "(root)"} in ${githubInfo.repositoryFullName}`);
-          const { data } = await octokit.rest.repos.getContent({
-            owner: githubInfo.owner,
-            repo: githubInfo.repo,
-            path: normalizedPath,
-            ref
-          });
-          if (!Array.isArray(data)) {
-            return {
-              content: [{
-                type: "text",
-                text: `\u274C "${directoryPath}" is not a directory.`
-              }]
-            };
+    return { content: [{ type: "text", text: responseText }] };
+  } catch (error) {
+    console.error("GitHub get file error:", error);
+    const status = error?.status;
+    if (status === 404) {
+      return {
+        content: [{ type: "text", text: `\u274C File not found: ${filePath}` }]
+      };
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      content: [
+        { type: "text", text: `\u274C Failed to read file: ${message}` }
+      ]
+    };
+  }
+}
+async function handleListGithubDirectory(input) {
+  const ctx = authContext;
+  const { projectId, directoryPath, ref } = input;
+  const githubInfo = await getGithubTokenForProject(projectId, ctx.teamId);
+  if (!githubInfo) {
+    return {
+      content: [
+        { type: "text", text: "\u274C GitHub not configured for this project." }
+      ]
+    };
+  }
+  try {
+    const octokit = new Octokit({ auth: githubInfo.token });
+    const normalizedPath = !directoryPath || directoryPath === "/" ? "" : directoryPath;
+    console.error(
+      `\u{1F4C1} Listing directory: ${normalizedPath || "(root)"} in ${githubInfo.repositoryFullName}`
+    );
+    const { data } = await octokit.rest.repos.getContent({
+      owner: githubInfo.owner,
+      repo: githubInfo.repo,
+      path: normalizedPath,
+      ref
+    });
+    if (!Array.isArray(data)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u274C "${directoryPath}" is not a directory.`
           }
-          let responseText = `\u{1F4C1} **Directory: ${directoryPath || "(root)"}**
+        ]
+      };
+    }
+    let responseText = `\u{1F4C1} **Directory: ${directoryPath || "(root)"}**
 `;
-          responseText += `Repository: ${githubInfo.repositoryFullName}
+    responseText += `Repository: ${githubInfo.repositoryFullName}
 `;
-          responseText += `Items: ${data.length}
+    responseText += `Items: ${data.length}
 
 `;
-          const directories = data.filter((item) => item.type === "dir");
-          const files = data.filter((item) => item.type === "file");
-          if (directories.length > 0) {
-            responseText += `**\u{1F4C1} Directories (${directories.length}):**
+    const directories = data.filter((item) => item.type === "dir");
+    const files = data.filter((item) => item.type === "file");
+    if (directories.length > 0) {
+      responseText += `**\u{1F4C1} Directories (${directories.length}):**
 `;
-            for (const dir of directories) {
-              responseText += `   - ${dir.name}/
+      for (const dir of directories) responseText += `   - ${dir.name}/
 `;
-            }
-            responseText += `
+      responseText += `
 `;
-          }
-          if (files.length > 0) {
-            responseText += `**\u{1F4C4} Files (${files.length}):**
+    }
+    if (files.length > 0) {
+      responseText += `**\u{1F4C4} Files (${files.length}):**
 `;
-            for (const file of files) {
-              responseText += `   - ${file.name} (${file.size} bytes)
+      for (const file of files)
+        responseText += `   - ${file.name} (${file.size} bytes)
 `;
-            }
-          }
-          return {
-            content: [{
-              type: "text",
-              text: responseText
-            }]
-          };
-        } catch (error) {
-          console.error("GitHub list directory error:", error);
-          if (error.status === 404) {
-            return {
-              content: [{
-                type: "text",
-                text: `\u274C Directory not found: ${directoryPath}`
-              }]
-            };
-          }
-          return {
-            content: [{
-              type: "text",
-              text: `\u274C Failed to list directory: ${error.message || "Unknown error"}`
-            }]
-          };
-        }
-      }
-      default:
-        throw new Error(`Unknown tool: ${name}`);
     }
+    return { content: [{ type: "text", text: responseText }] };
   } catch (error) {
-    console.error(`\u274C Tool execution error:`, error);
-    const message = error instanceof Error ? error.message : error?.message || error?.details || (typeof error === "string" ? error : JSON.stringify(error));
+    console.error("GitHub list directory error:", error);
+    const status = error?.status;
+    if (status === 404) {
+      return {
+        content: [
+          { type: "text", text: `\u274C Directory not found: ${directoryPath}` }
+        ]
+      };
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
     return {
-      content: [{
-        type: "text",
-        text: `Error executing ${name}: ${message}`
-      }]
+      content: [
+        { type: "text", text: `\u274C Failed to list directory: ${message}` }
+      ]
     };
   }
-});
+}
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   if (!authContext) {
     return {
-      contents: [{
-        uri: request.params.uri,
-        mimeType: "text/plain",
-        text: "Error: Not authenticated. API key validation failed."
-      }]
+      contents: [
+        {
+          uri: request.params.uri,
+          mimeType: "text/plain",
+          text: "Error: Not authenticated. API key validation failed."
+        }
+      ]
     };
   }
+  const ctx = authContext;
   const { uri } = request.params;
   console.error(`\u{1F4DA} Reading resource: ${uri}`);
   try {
     switch (uri) {
       case "tickets://recent": {
-        const teamIds = await getAccessibleTeamIds(authContext.teamId);
-        const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-        const customerIds = await getAccessibleCustomerIds(authContext.teamId);
-        let teamFilter = `team_id.in.(${teamIds.join(",")})`;
-        let projectFilter = projectIds.length > 0 ? `project_id.in.(${projectIds.join(",")})` : null;
-        let customerFilter = customerIds.length > 0 ? `customer_id.in.(${customerIds.join(",")})` : null;
-        const filters = [teamFilter, projectFilter, customerFilter].filter(Boolean);
-        const { data, error } = await supabase.from("tickets").select(`
-            id,
-            ticket_number,
-            title,
-            status,
-            priority,
-            created_at
-          `).or(filters.join(",")).order("created_at", { ascending: false }).limit(20);
-        if (error) throw error;
+        const teamIds = await getAccessibleTeamIds(ctx.teamId);
+        const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
+        const customerIds = await getAccessibleCustomerIds(ctx.teamId);
+        const accessPredicate = buildTicketAccessPredicate(
+          teamIds,
+          projectIds,
+          customerIds
+        );
+        const rows = await db.select({
+          id: schema.tickets.id,
+          ticketNumber: schema.tickets.ticketNumber,
+          title: schema.tickets.title,
+          status: schema.tickets.status,
+          priority: schema.tickets.priority,
+          createdAt: schema.tickets.createdAt
+        }).from(schema.tickets).where(and(accessPredicate, eq(schema.tickets.isDeleted, false))).orderBy(desc(schema.tickets.createdAt)).limit(20);
         return {
-          contents: [{
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(data, null, 2)
-          }]
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(rows, null, 2)
+            }
+          ]
         };
       }
       case "customers://all": {
-        const customerIds = await getAccessibleCustomerIds(authContext.teamId);
+        const customerIds = await getAccessibleCustomerIds(ctx.teamId);
         if (customerIds.length === 0) {
           return {
-            contents: [{
-              uri,
-              mimeType: "application/json",
-              text: JSON.stringify([], null, 2)
-            }]
+            contents: [
+              { uri, mimeType: "application/json", text: JSON.stringify([], null, 2) }
+            ]
           };
         }
-        const { data, error } = await supabase.from("customers").select("id, name, email, website, created_at").in("id", customerIds).order("name").limit(50);
-        if (error) throw error;
+        const rows = await db.select({
+          id: schema.customers.id,
+          name: schema.customers.name,
+          email: schema.customers.email,
+          website: schema.customers.website,
+          createdAt: schema.customers.createdAt
+        }).from(schema.customers).where(inArray(schema.customers.id, customerIds)).orderBy(asc(schema.customers.name)).limit(50);
         return {
-          contents: [{
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(data, null, 2)
-          }]
+          contents: [
+            { uri, mimeType: "application/json", text: JSON.stringify(rows, null, 2) }
+          ]
         };
       }
       case "projects://active": {
-        const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
+        const projectIds = await getAccessibleProjectIds(ctx.userId, ctx.teamId);
         if (projectIds.length === 0) {
           return {
-            contents: [{
-              uri,
-              mimeType: "application/json",
-              text: JSON.stringify([], null, 2)
-            }]
+            contents: [
+              { uri, mimeType: "application/json", text: JSON.stringify([], null, 2) }
+            ]
           };
         }
-        const { data, error } = await supabase.from("projects").select(`
-            id,
-            name,
-            description,
-            status,
-            created_at,
-            customers:customer_id(id, name)
-          `).in("id", projectIds).eq("status", "active").order("name").limit(50);
-        if (error) throw error;
+        const rows = await db.select({
+          id: schema.projects.id,
+          name: schema.projects.name,
+          description: schema.projects.description,
+          createdAt: schema.projects.createdAt,
+          customerId: schema.projects.customerId,
+          customerName: schema.customers.name
+        }).from(schema.projects).leftJoin(
+          schema.customers,
+          eq(schema.customers.id, schema.projects.customerId)
+        ).where(inArray(schema.projects.id, projectIds)).orderBy(asc(schema.projects.name)).limit(50);
         return {
-          contents: [{
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(data, null, 2)
-          }]
+          contents: [
+            { uri, mimeType: "application/json", text: JSON.stringify(rows, null, 2) }
+          ]
         };
       }
       default:
         throw new Error(`Unknown resource: ${uri}`);
     }
   } catch (error) {
-    console.error(`\u274C Resource read error:`, error);
+    console.error("\u274C Resource read error:", error);
     return {
-      contents: [{
-        uri,
-        mimeType: "text/plain",
-        text: `Error reading ${uri}: ${error instanceof Error ? error.message : "Unknown error"}`
-      }]
+      contents: [
+        {
+          uri,
+          mimeType: "text/plain",
+          text: `Error reading ${uri}: ${error instanceof Error ? error.message : "Unknown error"}`
+        }
+      ]
     };
   }
 });
 async function main() {
-  console.error("\u{1F680} Starting MG Tickets MCP Bridge Server...");
+  console.error("\u{1F680} Starting Refront MCP Bridge Server...");
   console.error(`\u{1F511} API Key: ${apiKey?.substring(0, 10)}...`);
   authContext = await validateApiKey(apiKey);
   if (!authContext) {
-    console.error("\u274C API key validation failed. Please check your key and try again.");
+    console.error(
+      "\u274C API key validation failed. Please check your key and try again."
+    );
     process.exit(1);
   }
-  console.error(`\u2705 Authenticated as user ${authContext.userId} in team ${authContext.teamId}`);
+  console.error(
+    `\u2705 Authenticated as user ${authContext.userId} in team ${authContext.teamId}`
+  );
   console.error(`\u{1F4CB} Available scopes: ${authContext.scopes.join(", ")}`);
   console.error("\u{1F4E1} MCP Bridge Server ready for connections");
   const transport = new StdioServerTransport();