@mgsoftwarebv/mcp-server-bridge 3.0.0 → 3.0.2

package/dist/index.js

@@ -1,46 +1,148 @@
 #!/usr/bin/env node
+import { createJobDb } from '@refront/db/job-client';
+import * as schema from '@refront/db/schema';
+import { eq, and, desc, inArray, asc, ilike, or, sql } from 'drizzle-orm';
+import { createHash } from 'crypto';
 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 { createStorageClient } from '@refront/storage';
+import { ensureTipTapFormat } from '@refront/utils/tiptap';
 
-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";
-if (!apiKey) {
-  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);
-function roundToNearest15Minutes(minutes) {
-  if (minutes <= 0) return 0;
-  return Math.round(minutes / 15) * 15;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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;
 }
 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];
+  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) {
-  const { data, error } = await supabase.rpc("get_accessible_project_ids", {
-    p_user_id: userId,
-    p_team_id: teamId
-  });
-  if (error) {
+  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 [];
   }
-  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])];
+  const ownCustomers = await db.select({ id: schema.customers.id }).from(schema.customers).where(inArray(schema.customers.teamId, teamIds));
+  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 getUserProviderTeams(userId) {
+  const rows = await db.select({
+    id: schema.teams.id,
+    name: schema.teams.name,
+    teamType: schema.teams.teamType
+  }).from(schema.usersOnTeam).leftJoin(schema.teams, eq(schema.usersOnTeam.teamId, schema.teams.id)).where(eq(schema.usersOnTeam.userId, userId));
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const row of rows) {
+    if (!row.id || row.teamType === "customer" || seen.has(row.id)) continue;
+    seen.add(row.id);
+    result.push({ id: row.id, name: row.name });
+  }
+  return result;
+}
+async function isUserTeamMember(userId, teamId) {
+  const [row] = await db.select({ id: schema.usersOnTeam.id }).from(schema.usersOnTeam).where(
+    and(
+      eq(schema.usersOnTeam.userId, userId),
+      eq(schema.usersOnTeam.teamId, teamId)
+    )
+  ).limit(1);
+  return Boolean(row);
+}
+async function getUserAccessibleTeamIds(userId) {
+  const teams2 = await getUserProviderTeams(userId);
+  const all = /* @__PURE__ */ new Set();
+  for (const team of teams2) {
+    const ids = await getAccessibleTeamIds(team.id);
+    ids.forEach((id) => all.add(id));
+  }
+  return [...all];
+}
+async function getUserAccessibleProjectIds(userId) {
+  const teams2 = await getUserProviderTeams(userId);
+  const all = /* @__PURE__ */ new Set();
+  for (const team of teams2) {
+    const ids = await getAccessibleProjectIds(userId, team.id);
+    ids.forEach((id) => all.add(id));
+  }
+  return [...all];
+}
+async function getUserAccessibleCustomerIds(userId) {
+  const teams2 = await getUserProviderTeams(userId);
+  const all = /* @__PURE__ */ new Set();
+  for (const team of teams2) {
+    const ids = await getAccessibleCustomerIds(team.id);
+    ids.forEach((id) => all.add(id));
+  }
+  return [...all];
+}
+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 _client, db;
+var init_db = __esm({
+  "src/db.ts"() {
+    _client = null;
+    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;
+      }
+    });
+  }
+});
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  authContext: () => authContext,
+  setAuthContext: () => setAuthContext,
+  validateApiKey: () => validateApiKey
+});
+function setAuthContext(ctx) {
+  authContext = ctx;
 }
 async function validateApiKey(key) {
   if (!key.startsWith("mid_") || key.length !== 68) {
@@ -50,164 +152,219 @@ 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);
     return null;
   }
 }
-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;
+var authContext;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    init_db();
+    authContext = null;
   }
+});
+
+// src/index.ts
+init_auth();
+
+// src/resources.ts
+init_auth();
+init_db();
+
+// src/types.ts
+init_db();
+function asToolArgs(input) {
+  return input ?? {};
 }
-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) {
-      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) {
-      console.error(`GitHub app not connected for team ${teamId}`);
-      return null;
-    }
-    const accessToken = appData.config.access_token;
-    const repositoryFullName = repoData.repository_full_name;
-    const [owner, repo] = repositoryFullName.split("/");
-    if (!owner || !repo) {
-      console.error(`Invalid repository full name: ${repositoryFullName}`);
-      return null;
-    }
+function roundToNearest15Minutes(minutes) {
+  if (minutes <= 0) return 0;
+  return Math.round(minutes / 15) * 15;
+}
+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);
+}
+
+// src/resources.ts
+async function handleReadResource(uri) {
+  if (!authContext) {
     return {
-      token: accessToken,
-      repositoryFullName,
-      owner,
-      repo
+      contents: [
+        {
+          uri,
+          mimeType: "text/plain",
+          text: "Error: Not authenticated. API key validation failed."
+        }
+      ]
     };
-  } catch (error) {
-    console.error("Error getting GitHub token for project:", error);
-    return null;
   }
-}
-async function transitionToNextPhase(sessionId, currentPhase) {
+  const ctx = authContext;
+  console.error(`\u{1F4DA} Reading resource: ${uri}`);
   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;
-    }
-    let currentPhaseType = currentPhase;
-    if (!currentPhaseType) {
-      const activePhase = allPhases.find((p) => p.status === "in_progress");
-      currentPhaseType = activePhase?.activity_type;
-    }
-    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);
-        console.error("\u2705 Started analysis phase");
+    switch (uri) {
+      case "tickets://recent": {
+        const teamIds = await getUserAccessibleTeamIds(ctx.userId);
+        const projectIds = await getUserAccessibleProjectIds(ctx.userId);
+        const customerIds = await getUserAccessibleCustomerIds(ctx.userId);
+        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(rows, null, 2)
+            }
+          ]
+        };
       }
-      return;
-    }
-    const currentPhaseRecord = allPhases.find((p) => p.activity_type === 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({
-        status: "completed",
-        ended_at: now.toISOString(),
-        duration_seconds: duration
-      }).eq("id", currentPhaseRecord.id);
-      console.error(`\u2705 Completed phase: ${currentPhaseType} (${duration}s)`);
-    }
-    const currentIndex = phaseOrder.indexOf(currentPhaseType);
-    if (currentIndex === -1 || currentIndex === phaseOrder.length - 1) {
-      console.error("No next phase to transition to");
-      return;
-    }
-    for (let i = currentIndex + 1; i < phaseOrder.length; i++) {
-      const nextPhaseType = phaseOrder[i];
-      const nextPhase = allPhases.find((p) => p.activity_type === 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)`);
-        continue;
+      case "customers://all": {
+        const customerIds = await getUserAccessibleCustomerIds(ctx.userId);
+        if (customerIds.length === 0) {
+          return {
+            contents: [
+              { uri, mimeType: "application/json", text: JSON.stringify([], null, 2) }
+            ]
+          };
+        }
+        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(rows, null, 2) }
+          ]
+        };
       }
-      if (nextPhase.status === "pending") {
-        await supabase.from("ai_time_logs").update({
-          status: "in_progress",
-          started_at: now.toISOString()
-        }).eq("id", nextPhase.id);
-        console.error(`\u2705 Started next phase: ${nextPhaseType}`);
-        return;
+      case "projects://active": {
+        const projectIds = await getUserAccessibleProjectIds(ctx.userId);
+        if (projectIds.length === 0) {
+          return {
+            contents: [
+              { uri, mimeType: "application/json", text: JSON.stringify([], null, 2) }
+            ]
+          };
+        }
+        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(rows, null, 2) }
+          ]
+        };
       }
+      default:
+        throw new Error(`Unknown resource: ${uri}`);
     }
-    console.error("All remaining phases skipped or completed");
   } catch (error) {
-    console.error("Error transitioning to next phase:", 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"}`
+        }
+      ]
+    };
   }
 }
-var server = new Server(
-  {
-    name: "mg-tickets-mcp-bridge",
-    version: "2.0.0"
-  },
+
+// src/tools/definitions.ts
+var teamIdProp = {
+  type: "string",
+  description: "Provider team ID. Optional when you belong to a single provider; required when you belong to several. Call get-teams to list the providers you can act on."
+};
+var TOOLS = [
   {
-    capabilities: {
-      tools: {},
-      resources: {}
+    name: "get-teams",
+    description: "List the provider teams (workspaces) you can act on. Use a returned id as the `teamId` argument on other tools. Call this when a tool says you belong to multiple providers.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
     }
-  }
-);
-var TOOLS = [
+  },
   {
     name: "get-tickets",
     description: "Get tickets with optional filtering by status, priority, project, customer, or search query",
     inputSchema: {
       type: "object",
       properties: {
-        status: { type: "string", enum: ["open", "in_progress", "review", "resolved", "closed", "backlog"] },
-        priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+        teamId: teamIdProp,
+        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: []
@@ -215,10 +372,11 @@ var TOOLS = [
   },
   {
     name: "get-ticket-by-id",
-    description: "Get a specific ticket by its ID, including all attachments, comments, and images. Images from ticket attachments and comment attachments are automatically downloaded and returned as base64-encoded content that can be analyzed by AI.",
+    description: "Get a specific ticket by its ID, including comment text and a full attachment listing (with ids). Images from ticket and comment attachments are downloaded and returned inline as base64. For non-image attachments, call get-ticket-attachment with the listed id to get a download URL.",
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         id: { type: "string", description: "Ticket ID" }
       },
       required: ["id"]
@@ -230,24 +388,146 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         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" }
       },
       required: ["title"]
     }
   },
+  {
+    name: "update-ticket",
+    description: "Update an existing ticket's fields (title, description, status, priority, type, project, customer, assignee, estimated hours). Only provided fields are changed. Changes are written to the ticket activity feed but do NOT send notifications. Set assigneeId to null to unassign; a provided assigneeId must be a member of the ticket's team. Common workflow: set status=in_progress when starting work; after merge/push set status=review and assigneeId to the requester (creator) id from get-ticket-by-id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        id: { type: "string", description: "Ticket ID" },
+        title: { type: "string" },
+        description: {
+          type: "string",
+          description: "Plain text or TipTap JSON; plain text is converted."
+        },
+        status: {
+          type: "string",
+          enum: [
+            "open",
+            "in_progress",
+            "review",
+            "resolved",
+            "closed",
+            "backlog"
+          ]
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "medium", "high", "critical"]
+        },
+        type: {
+          type: "string",
+          enum: [
+            "task",
+            "bug",
+            "feature",
+            "support",
+            "question",
+            "improvement"
+          ]
+        },
+        projectId: { type: "string" },
+        customerId: { type: "string" },
+        assigneeId: {
+          type: ["string", "null"],
+          description: "User ID to assign, or null to unassign."
+        },
+        estimatedHours: { type: "number" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "add-ticket-comment",
+    description: "Add a comment to a ticket. Content can be plain text or TipTap JSON. Set isInternal=true for an internal-only note. The comment appears in the ticket activity feed but does NOT send notifications or trigger @mention routing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        ticketId: { type: "string", description: "Ticket ID" },
+        content: { type: "string", description: "Comment body" },
+        isInternal: { type: "boolean", default: false }
+      },
+      required: ["ticketId", "content"]
+    }
+  },
+  {
+    name: "get-ticket-comments",
+    description: "Get all comments for a ticket, rendered as plain text with author, internal flag, and timestamp.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        ticketId: { type: "string", description: "Ticket ID" }
+      },
+      required: ["ticketId"]
+    }
+  },
+  {
+    name: "get-ticket-attachment",
+    description: "Get a temporary signed download URL (valid 1 hour) for any ticket or comment attachment by its id. Works for any file type (PDF, docx, zip, images). Find attachment ids via get-ticket-by-id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        attachmentId: {
+          type: "string",
+          description: "Attachment ID (ticket or comment attachment)"
+        }
+      },
+      required: ["attachmentId"]
+    }
+  },
   {
     name: "get-customers",
     description: "Get customers with optional search",
     inputSchema: {
       type: "object",
       properties: {
-        q: { type: "string", description: "Search query for customer name or email" },
+        teamId: teamIdProp,
+        q: {
+          type: "string",
+          description: "Search query for customer name or email"
+        },
         pageSize: { type: "number", default: 20, maximum: 100 }
       },
       required: []
@@ -259,6 +539,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         name: { type: "string", description: "Customer name" },
         email: { type: "string" },
         website: { type: "string" }
@@ -272,6 +553,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         customerId: { type: "string", description: "Filter by customer ID" },
         q: { type: "string", description: "Search query for project name" },
         pageSize: { type: "number", default: 20, maximum: 100 }
@@ -285,24 +567,32 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         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",
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         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)"
@@ -323,13 +613,19 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         originalPrompt: { type: "string" },
         aiResponse: { type: "string" },
         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 +641,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"
+      ]
     }
   },
   {
@@ -354,6 +658,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         includeTicketData: { type: "boolean", default: true },
         includeTodoProgress: { type: "boolean", default: true },
@@ -368,15 +673,22 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         todos: {
           type: "array",
           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"]
@@ -397,6 +709,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         newTodos: {
           type: "array",
@@ -404,7 +717,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 }
             },
@@ -425,6 +742,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         status: {
           type: "string",
@@ -442,6 +760,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         includeFollowUps: { type: "boolean", default: true },
         includeTimeMetrics: { type: "boolean", default: true },
@@ -456,8 +775,12 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         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"],
@@ -473,6 +796,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         aiSessionId: { type: "string" },
         workCompleted: {
           type: "array",
@@ -498,6 +822,7 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
+        teamId: teamIdProp,
         projectId: {
           type: "string",
           description: "Project ID (UUID) - Optional. Cursor AI should call get-projects first to try matching workspace name. If no clear match, omit this field."
@@ -526,17 +851,14 @@ 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)"
-        },
+        teamId: teamIdProp,
+        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 +877,8 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        projectId: {
-          type: "string",
-          description: "Project ID (UUID)"
-        },
+        teamId: teamIdProp,
+        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,411 +912,1094 @@ var RESOURCES = [
     mimeType: "application/json"
   }
 ];
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return { tools: TOOLS };
-});
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  return { resources: RESOURCES };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (!authContext) {
+
+// src/tools/customers.ts
+init_db();
+
+// src/tools/team-resolution.ts
+init_auth();
+init_db();
+function teamSelectionResponse(teams2) {
+  const list = teams2.map((t) => `- ${t.name ?? "(unnamed provider)"} (teamId: ${t.id})`).join("\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `You belong to multiple providers, so this action is ambiguous. Re-call this tool with a \`teamId\` set to the intended provider.
+
+Available providers:
+${list}
+
+Ask the user which provider to use (or infer it from the conversation), then call the tool again with the chosen \`teamId\`.`
+      }
+    ]
+  };
+}
+function notAMemberResponse(teamId) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Access denied: you are not a member of team ${teamId}. Call \`get-teams\` to list the providers you can act on.`
+      }
+    ]
+  };
+}
+async function resolveTeamId(requestedTeamId) {
+  const ctx = authContext;
+  if (requestedTeamId) {
+    const member = await isUserTeamMember(ctx.userId, requestedTeamId);
+    if (!member) {
+      return { ok: false, response: notAMemberResponse(requestedTeamId) };
+    }
+    return { ok: true, teamId: requestedTeamId };
+  }
+  const teams2 = await getUserProviderTeams(ctx.userId);
+  if (teams2.length === 0) {
+    return { ok: true, teamId: ctx.teamId };
+  }
+  if (teams2.length === 1) {
+    return { ok: true, teamId: teams2[0].id };
+  }
+  return { ok: false, response: teamSelectionResponse(teams2) };
+}
+async function resolveTeamScope(requestedTeamId) {
+  const ctx = authContext;
+  if (requestedTeamId) {
+    const member = await isUserTeamMember(ctx.userId, requestedTeamId);
+    if (!member) {
+      return { ok: false, response: notAMemberResponse(requestedTeamId) };
+    }
+    const [teamIds2, projectIds2, customerIds2] = await Promise.all([
+      getAccessibleTeamIds(requestedTeamId),
+      getAccessibleProjectIds(ctx.userId, requestedTeamId),
+      getAccessibleCustomerIds(requestedTeamId)
+    ]);
+    return { ok: true, teamIds: teamIds2, projectIds: projectIds2, customerIds: customerIds2 };
+  }
+  const [teamIds, projectIds, customerIds] = await Promise.all([
+    getUserAccessibleTeamIds(ctx.userId),
+    getUserAccessibleProjectIds(ctx.userId),
+    getUserAccessibleCustomerIds(ctx.userId)
+  ]);
+  return { ok: true, teamIds, projectIds, customerIds };
+}
+
+// src/tools/customers.ts
+async function handleGetCustomers(input) {
+  const { q, pageSize = 20 } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const customerIds = await getAccessibleCustomerIds(resolved.teamId);
+  if (customerIds.length === 0) {
     return {
-      content: [{ type: "text", text: "Error: Not authenticated. API key validation failed." }]
+      content: [
+        {
+          type: "text",
+          text: "No customers found or no access to any customers."
+        }
+      ]
     };
   }
-  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:
-
-${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()}
+  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:
+
+${rows.map(
+          (c) => `**${c.name}**
+${c.email ? `Email: ${c.email}
+` : ""}${c.website ? `Website: ${c.website}
+` : ""}Created: ${new Date(c.createdAt).toLocaleDateString()}
 `
-            ).join("\n") || "No tickets found."}`
-          }]
-        };
+        ).join("\n") || "No customers 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);
-        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;
-        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,
-            user_id
-          `).eq("ticket_id", id).order("created_at", { ascending: true });
-        if (commentsError) {
-          console.error("Error fetching comments:", commentsError);
-        }
-        const commentUserIds = [...new Set(comments?.map((c) => c.user_id).filter(Boolean) || [])];
-        const commentUserMap = /* @__PURE__ */ new Map();
-        if (commentUserIds.length > 0) {
-          const { data: commentUsers } = await supabase.from("users").select("id, full_name").in("id", commentUserIds);
-          commentUsers?.forEach((u) => commentUserMap.set(u.id, u));
-        }
-        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:**
-
-**${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 ? `
-\u{1F4CE} Attachments: ${attachments.length}
-` : ""}${comments && comments.length > 0 ? `\u{1F4AC} Comments: ${comments.length}
+    ]
+  };
+}
+async function handleCreateCustomer(input) {
+  const { name, email, website } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  await db.insert(schema.customers).values({
+    teamId: resolved.teamId,
+    name,
+    email: email ?? "",
+    website: website ?? null
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Customer Created Successfully!**
+
+Name: ${name}
+${email ? `Email: ${email}
+` : ""}${website ? `Website: ${website}
 ` : ""}`
-        }];
-        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 (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 ${commentUserMap.get(comment?.user_id)?.full_name || "Unknown"} on ${new Date(attachment.created_at).toLocaleDateString()}: ${attachment.file_name} (${Math.round(attachment.file_size / 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;
-            }
+    ]
+  };
+}
+
+// src/tools/github.ts
+init_db();
+async function getGithubTokenForProject(projectId, teamIds) {
+  try {
+    if (teamIds.length === 0) return null;
+    const [repoData] = await db.select({
+      repositoryFullName: schema.projectGithubRepositories.repositoryFullName,
+      teamId: schema.projectGithubRepositories.teamId
+    }).from(schema.projectGithubRepositories).where(
+      and(
+        eq(schema.projectGithubRepositories.projectId, projectId),
+        inArray(schema.projectGithubRepositories.teamId, teamIds)
+      )
+    ).limit(1);
+    if (!repoData) {
+      console.error(`No GitHub repository linked to project ${projectId}`);
+      return null;
+    }
+    const teamId = repoData.teamId;
+    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 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 };
+  } catch (error) {
+    console.error("Error getting GitHub token for project:", error);
+    return null;
+  }
+}
+async function handleGetGithubFile(input) {
+  const { projectId, filePath, ref } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const githubInfo = await getGithubTokenForProject(projectId, scope.teamIds);
+  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.`
           }
-          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")}`;
-        }
-        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: [{
+        ]
+      };
+    }
+    const content = Buffer.from(data.content, "base64").toString("utf-8");
+    let responseText = `\u{1F4C4} **File: ${filePath}**
+`;
+    responseText += `Repository: ${githubInfo.repositoryFullName}
+`;
+    responseText += `Size: ${data.size} bytes
+`;
+    responseText += `URL: ${data.html_url}
+
+`;
+    responseText += `**Content:**
+\`\`\`
+${content}
+\`\`\``;
+    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 { projectId, directoryPath, ref } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const githubInfo = await getGithubTokenForProject(projectId, scope.teamIds);
+  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: `\u2705 **Ticket Created Successfully!**
+            text: `\u274C "${directoryPath}" is not a directory.`
+          }
+        ]
+      };
+    }
+    let responseText = `\u{1F4C1} **Directory: ${directoryPath || "(root)"}**
+`;
+    responseText += `Repository: ${githubInfo.repositoryFullName}
+`;
+    responseText += `Items: ${data.length}
 
-Ticket Number: **${ticketNumber}**
-Title: ${title}
-Status: ${status}
-Priority: ${priority}
-Type: ${type}
-`
-          }]
-        };
+`;
+    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}/
+`;
+      responseText += `
+`;
+    }
+    if (files.length > 0) {
+      responseText += `**\u{1F4C4} Files (${files.length}):**
+`;
+      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);
+    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: `\u274C Failed to list directory: ${message}` }
+      ]
+    };
+  }
+}
+
+// src/tools/hours.ts
+init_auth();
+init_db();
+async function handleLogHours(input) {
+  const ctx = authContext;
+  const {
+    projectId,
+    ticketId,
+    aiSessionId,
+    workDescription,
+    estimatedHours,
+    chatContextSummary
+  } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  let project = null;
+  let ticket = null;
+  let aiSession = null;
+  if (projectId) {
+    if (!scope.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;
+    if (scope.teamIds.includes(ticketData.teamId)) hasAccess = true;
+    if (!hasAccess && ticketData.projectId && scope.projectIds.includes(ticketData.projectId))
+      hasAccess = true;
+    if (!hasAccess && ticketData.customerId && scope.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;
+  }
+  let insertTeamId = ticket?.teamId ?? project?.teamId ?? null;
+  if (!insertTeamId) {
+    const resolved = await resolveTeamId(input.teamId);
+    if (!resolved.ok) return resolved.response;
+    insertTeamId = resolved.teamId;
+  }
+  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.timesheetEvents.id,
+        trackedDuration: schema.timesheetEvents.trackedDuration,
+        projectId: schema.timesheetEvents.projectId,
+        aiSessionId: schema.timesheetEvents.aiSessionId
+      }).from(schema.timesheetEvents).where(
+        and(
+          eq(schema.timesheetEvents.status, "draft"),
+          eq(schema.timesheetEvents.userId, ctx.userId),
+          eq(schema.timesheetEvents.aiSessionId, aiSession.id)
+        )
+      ).orderBy(desc(schema.timesheetEvents.createdAt));
+    } else if (ticket?.id) {
+      const linkedEvents = await db.select({
+        timesheetEventId: schema.timesheetEventTickets.timesheetEventId
+      }).from(schema.timesheetEventTickets).where(eq(schema.timesheetEventTickets.ticketId, ticket.id));
+      const eventIds = linkedEvents.map((e) => e.timesheetEventId);
+      if (eventIds.length > 0) {
+        existingEntries = await db.select({
+          id: schema.timesheetEvents.id,
+          trackedDuration: schema.timesheetEvents.trackedDuration,
+          projectId: schema.timesheetEvents.projectId,
+          aiSessionId: schema.timesheetEvents.aiSessionId
+        }).from(schema.timesheetEvents).where(
+          and(
+            inArray(schema.timesheetEvents.id, eventIds),
+            eq(schema.timesheetEvents.status, "draft"),
+            eq(schema.timesheetEvents.userId, ctx.userId)
+          )
+        ).orderBy(desc(schema.timesheetEvents.createdAt));
       }
-      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."
-            }]
-          };
+    }
+    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.timesheetEvents).where(inArray(schema.timesheetEvents.id, duplicateIds));
+        consolidatedCount = existingEntries.length - 1;
+      }
+      const newDuration = (existingEntry.trackedDuration ?? 0) + durationSeconds;
+      const [updated] = await db.update(schema.timesheetEvents).set({
+        trackedDuration: newDuration,
+        endTime: now.toISOString(),
+        title: workDescription,
+        description: chatContextSummary ?? workDescription,
+        projectId: project?.id ?? existingEntry.projectId
+      }).where(eq(schema.timesheetEvents.id, existingEntry.id)).returning({
+        id: schema.timesheetEvents.id,
+        trackedDuration: schema.timesheetEvents.trackedDuration,
+        projectId: schema.timesheetEvents.projectId,
+        aiSessionId: schema.timesheetEvents.aiSessionId
+      });
+      agendaEntry = updated ?? null;
+      wasUpdated = true;
+    }
+  }
+  if (!agendaEntry) {
+    const startTime = new Date(now.getTime() - durationSeconds * 1e3);
+    const [created] = await db.insert(schema.timesheetEvents).values({
+      teamId: insertTeamId,
+      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.timesheetEvents.id,
+      trackedDuration: schema.timesheetEvents.trackedDuration,
+      projectId: schema.timesheetEvents.projectId,
+      aiSessionId: schema.timesheetEvents.aiSessionId
+    });
+    agendaEntry = created ?? null;
+    if (agendaEntry && ticket?.id) {
+      await db.insert(schema.timesheetEventTickets).values({ timesheetEventId: 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)
+`;
+    responseText += `   \u2022 New total: ${Math.round((agendaEntry.trackedDuration ?? 0) / 3600 * 10) / 10}h
+
+`;
+  }
+  if (consolidatedCount > 0) {
+    responseText += `\u{1F9F9} **Cleaned up ${consolidatedCount} duplicate entries**
+
+`;
+  }
+  responseText += `\u{1F4CB} **Entry Details:**
+`;
+  responseText += `   \u2022 Project: ${project ? project.name : "(No project assigned)"}
+`;
+  if (ticket)
+    responseText += `   \u2022 Ticket: ${ticket.title} (${ticket.status})
+`;
+  if (aiSession)
+    responseText += `   \u2022 AI Session: ${aiSession.id} (${aiSession.status})
+`;
+  responseText += `   \u2022 Description: ${workDescription}
+`;
+  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 Entry ID: ${agendaEntry.id}
+
+`;
+  if (chatContextSummary) {
+    responseText += `\u{1F4CA} **Work Context:**
+`;
+    responseText += `${chatContextSummary.substring(0, 200)}${chatContextSummary.length > 200 ? "..." : ""}
+
+`;
+  }
+  responseText += `\u2705 Time entry ${wasUpdated ? "updated" : "created"} and ready for review in the agenda!`;
+  return { content: [{ type: "text", text: responseText }] };
+}
+
+// src/tools/projects.ts
+init_auth();
+init_db();
+async function handleGetProjects(input) {
+  const ctx = authContext;
+  const { customerId, q, pageSize = 20 } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const projectIds = await getAccessibleProjectIds(ctx.userId, resolved.teamId);
+  if (projectIds.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No projects found or no access to any projects."
         }
-        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.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(
-              (customer) => `**${customer.name}**
-${customer.email ? `Email: ${customer.email}
-` : ""}${customer.website ? `Website: ${customer.website}
-` : ""}Created: ${new Date(customer.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 customers found."}`
-          }]
-        };
+        ).join("\n") || "No projects 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 handleCreateProject(input) {
+  const { name, description, customerId } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  await db.insert(schema.projects).values({
+    teamId: resolved.teamId,
+    name,
+    description: description ?? null,
+    customerId: customerId ?? null
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Project Created Successfully!**
 
-Name: ${name2}
-${email ? `Email: ${email}
-` : ""}${website ? `Website: ${website}
+Name: ${name}
+${description ? `Description: ${description}
 ` : ""}`
-          }]
-        };
       }
-      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."
-            }]
-          };
-        }
-        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:
+    ]
+  };
+}
 
-${data?.map(
-              (project) => `**${project.name}** (ID: ${project.id})
-${project.description ? `Description: ${project.description}
-` : ""}Created: ${new Date(project.created_at).toLocaleDateString()}
-`
-            ).join("\n") || "No projects found."}`
-          }]
-        };
+// src/tools/session-completion.ts
+init_auth();
+init_db();
+async function handleGetCompletionContext(input) {
+  const {
+    aiSessionId,
+    includeFollowUps = true,
+    includeTimeMetrics = true,
+    includeTodos = true
+  } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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.ticketNumber} - ${ticket.title}
+\u{1F194} **Session:** ${aiSessionId} (${session.status})
+\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 "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 handleSaveCustomerResponse(input) {
+  const { aiSessionId, customerResponse, responseType = "completion" } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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!**
 
-Name: ${name2}
-Status: ${status}
-${description ? `Description: ${description}
-` : ""}`
-          }]
-        };
+\u{1F194} Session: ${aiSessionId}
+\u{1F4DD} Response Type: ${responseType}
+\u{1F4C4} Length: ${customerResponse.length} characters
+
+\u2705 **Response ready for provider approval**
+\u{1F50D} Provider can review in AI tab before sending to customer
+
+**Preview:**
+\`\`\`
+${customerResponse.substring(0, 200)}${customerResponse.length > 200 ? "..." : ""}\`\`\``
       }
-      // === 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 handleCompleteAiSession(input) {
+  const ctx = authContext;
+  const {
+    aiSessionId,
+    workCompleted,
+    technicalSummary,
+    invoiceDescription,
+    efficiencyNotes
+  } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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,
+    teamId: schema.aiSessions.teamId
+  }).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.aiTimeEstimateMinutes ?? timeSpentMinutes;
+  const sessionStart = new Date(session.createdAt);
+  const estimatedEnd = new Date(
+    sessionStart.getTime() + estimatedMinutes * 6e4
+  );
+  const existingAgendaEntries = await db.select({
+    id: schema.timesheetEvents.id,
+    trackedDuration: schema.timesheetEvents.trackedDuration
+  }).from(schema.timesheetEvents).where(
+    and(
+      eq(schema.timesheetEvents.aiSessionId, session.id),
+      eq(schema.timesheetEvents.status, "draft")
+    )
+  ).orderBy(desc(schema.timesheetEvents.createdAt));
+  let timesheetEventId = 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.timesheetEvents).where(inArray(schema.timesheetEvents.id, duplicateIds));
+    consolidatedCount = existingAgendaEntries.length - 1;
+  }
+  try {
+    if (existingAgendaEntry) {
+      const [updated] = await db.update(schema.timesheetEvents).set({
+        title: ticketInfo?.title || "Development Work",
+        description: completionDescription,
+        endTime: estimatedEnd.toISOString(),
+        projectId: ticketInfo?.projectId ?? null,
+        trackedDuration: estimatedMinutes * 60
+      }).where(eq(schema.timesheetEvents.id, existingAgendaEntry.id)).returning({ id: schema.timesheetEvents.id });
+      timesheetEventId = updated?.id ?? null;
+      wasUpdated = true;
+    } else {
+      const [created] = await db.insert(schema.timesheetEvents).values({
+        teamId: existingSession.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.timesheetEvents.id });
+      timesheetEventId = created?.id ?? null;
+    }
+    if (timesheetEventId && session.ticketId) {
+      await db.insert(schema.timesheetEventTickets).values({
+        timesheetEventId,
+        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{1F4CA} **Performance Summary:**
+`;
+  responseText += `   \u2022 Tasks Completed: ${workCompleted.length}
+`;
+  responseText += `   \u2022 Time Spent: ${timeSpentMinutes} 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 Session Duration: ${sessionDuration} minutes
+
+`;
+  responseText += `\u2705 **Work Completed:**
+`;
+  workCompleted.forEach((task, index) => {
+    responseText += `${index + 1}. ${task}
+`;
+  });
+  responseText += `
+`;
+  if (technicalSummary) {
+    responseText += `\u{1F527} **Technical Summary:**
+${technicalSummary}
+
+`;
+  }
+  if (efficiencyNotes) {
+    responseText += `\u{1F4C8} **Efficiency Notes:**
+${efficiencyNotes}
+
+`;
+  }
+  if (timesheetEventId) {
+    responseText += `\u{1F4C5} **Timetrack Entry ${wasUpdated ? "Updated" : "Created"}:**
+`;
+    responseText += `   \u2022 Agenda event ${wasUpdated ? "updated with final" : "created with"} work summary
+`;
+    responseText += `   \u2022 Status: DRAFT (requires approval in agenda)
+`;
+    responseText += `   \u2022 Duration: ${estimatedMinutes} minutes
+`;
+    responseText += `   \u2022 Period: ${sessionStart.toLocaleString()} - ${completionTime.toLocaleString()}
+
+`;
+  }
+  responseText += `\u{1F4CB} **Context for Customer Response:**
+`;
+  responseText += `   \u2022 Use "get-completion-context" to retrieve full context
+`;
+  responseText += `   \u2022 Generate customer-friendly response based on completed work
+`;
+  responseText += `   \u2022 Focus on business value and customer benefits
+
+`;
+  responseText += `\u{1F3AF} **Session archived successfully!**`;
+  return { content: [{ type: "text", text: responseText }] };
+}
+
+// src/tools/sessions.ts
+init_auth();
+init_db();
+async function transitionToNextPhase(sessionId, currentPhase) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    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?.activityType ?? void 0;
+    }
+    if (!currentPhaseType) {
+      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.activityType === currentPhaseType && p.status === "in_progress"
+    );
+    if (currentPhaseRecord) {
+      const duration = Math.round(
+        (now.getTime() - new Date(currentPhaseRecord.startedAt).getTime()) / 1e3
+      );
+      await db.update(schema.aiTimeLogs).set({
+        status: "completed",
+        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);
+    if (currentIndex === -1 || currentIndex === phaseOrder.length - 1) {
+      console.error("No next phase to transition to");
+      return;
+    }
+    for (let i = currentIndex + 1; i < phaseOrder.length; i++) {
+      const nextPhaseType = phaseOrder[i];
+      const nextPhase = allPhases.find((p) => p.activityType === nextPhaseType);
+      if (!nextPhase) continue;
+      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 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;
+      }
+    }
+    console.error("All remaining phases skipped or completed");
+  } catch (error) {
+    console.error("Error transitioning to next phase:", error);
+  }
+}
+async function handleStartAiSession(input) {
+  const ctx = authContext;
+  const { ticketId, cursorSessionId, totalEstimatedMinutes, complexityScore } = input;
+  if (!totalEstimatedMinutes) {
+    throw new Error("totalEstimatedMinutes is required");
+  }
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const [ticketRow] = await db.select({
+    teamId: schema.tickets.teamId,
+    projectId: schema.tickets.projectId,
+    customerId: schema.tickets.customerId
+  }).from(schema.tickets).where(eq(schema.tickets.id, ticketId)).limit(1);
+  if (!ticketRow) {
+    throw new Error(
+      `Ticket not found: ${ticketId}. Call get-tickets to find the correct ticket.`
+    );
+  }
+  const hasTicketAccess = scope.teamIds.includes(ticketRow.teamId) || !!ticketRow.projectId && scope.projectIds.includes(ticketRow.projectId) || !!ticketRow.customerId && scope.customerIds.includes(ticketRow.customerId);
+  if (!hasTicketAccess) {
+    throw new Error(`No access to ticket: ${ticketId}.`);
+  }
+  const insertTeamId = ticketRow.teamId;
+  const roundedMinutes = roundToNearest15Minutes(totalEstimatedMinutes);
+  const sessionStartTime = /* @__PURE__ */ new Date();
+  const [sessionData] = await db.insert(schema.aiSessions).values({
+    ticketId,
+    providerUserId: ctx.userId,
+    teamId: insertTeamId,
+    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}
@@ -1005,115 +2008,144 @@ ${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 scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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,
+    teamId: schema.aiSessions.teamId
+  }).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: session.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.timesheetEvents.id,
+    trackedDuration: schema.timesheetEvents.trackedDuration,
+    title: schema.timesheetEvents.title,
+    description: schema.timesheetEvents.description,
+    startTime: schema.timesheetEvents.startTime
+  }).from(schema.timesheetEvents).where(
+    and(
+      eq(schema.timesheetEvents.aiSessionId, session.id),
+      eq(schema.timesheetEvents.status, "draft")
+    )
+  ).orderBy(desc(schema.timesheetEvents.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.timesheetEvents).where(inArray(schema.timesheetEvents.id, duplicateIds));
+    if (existingEntry && totalExistingDuration > (existingEntry.trackedDuration ?? 0)) {
+      await db.update(schema.timesheetEvents).set({ trackedDuration: totalExistingDuration }).where(eq(schema.timesheetEvents.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.timesheetEvents).set({
+      trackedDuration: newDuration,
+      endTime: followUpTime.toISOString(),
+      title: workDescription,
+      description: workDescription
+    }).where(eq(schema.timesheetEvents.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.timesheetEvents).values({
+      teamId: session.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("_", " ")}
@@ -1131,197 +2163,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 {
+    aiSessionId,
+    includeTicketData = true,
+    includeTodoProgress = true,
+    includeFollowUpHistory = false
+  } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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 { aiSessionId, todos, replaceAll = true } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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 { aiSessionId, newTodos, followUpReason } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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 { aiSessionId, status, actualTimeMinutes, completionNotes } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const prefix = aiSessionId.replace("ai-sess-", "");
+  const fullSessionId = await resolveAiSessionId(prefix, scope.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}
@@ -1329,742 +2386,952 @@ ${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!**
+    ]
+  };
+}
 
-\u{1F3AB} **Ticket:** ${ticket.ticket_number} - ${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}
+// src/tools/teams.ts
+init_auth();
+init_db();
+async function handleGetTeams() {
+  const ctx = authContext;
+  const teams2 = await getUserProviderTeams(ctx.userId);
+  if (teams2.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "You are not a member of any provider team."
+        }
+      ]
+    };
+  }
+  const list = teams2.map((t) => `- ${t.name ?? "(unnamed provider)"} (teamId: ${t.id})`).join("\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `You can act on ${teams2.length} provider${teams2.length === 1 ? "" : "s"}. Pass the chosen \`teamId\` to other tools when needed.
 
-\u2705 **Full context ready for Cursor AI to generate customer response!**
+${list}
 
-**Context Data:**
-\`\`\`json
-${JSON.stringify(contextData, null, 2)}\`\`\``
-          }]
-        };
+${JSON.stringify(teams2)}`
       }
-      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!**
-
-\u{1F194} Session: ${aiSessionId}
-\u{1F4DD} Response Type: ${responseType}
-\u{1F4C4} Length: ${customerResponse.length} characters
+    ]
+  };
+}
 
-\u2705 **Response ready for provider approval**
-\u{1F50D} Provider can review in AI tab before sending to customer
+// src/tools/ticket-attachments.ts
+init_db();
+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);
+  }
+});
 
-**Preview:**
-\`\`\`
-${customerResponse.substring(0, 200)}${customerResponse.length > 200 ? "..." : ""}\`\`\``
-          }]
-        };
+// src/tools/ticket-access.ts
+init_db();
+function notFoundResponse(ticketId) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Ticket not found or no access: ${ticketId}. Call get-tickets to find the correct ticket.`
       }
-      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 loadAccessibleTicket(requestedTeamId, ticketId) {
+  const scope = await resolveTeamScope(requestedTeamId);
+  if (!scope.ok) return scope;
+  const [ticket] = await db.select({
+    id: schema.tickets.id,
+    teamId: schema.tickets.teamId,
+    projectId: schema.tickets.projectId,
+    customerId: schema.tickets.customerId,
+    ticketNumber: schema.tickets.ticketNumber,
+    title: schema.tickets.title,
+    status: schema.tickets.status,
+    priority: schema.tickets.priority,
+    type: schema.tickets.type,
+    assigneeId: schema.tickets.assigneeId
+  }).from(schema.tickets).where(eq(schema.tickets.id, ticketId)).limit(1);
+  if (!ticket) return { ok: false, response: notFoundResponse(ticketId) };
+  const hasAccess = scope.teamIds.includes(ticket.teamId) || !!ticket.projectId && scope.projectIds.includes(ticket.projectId) || !!ticket.customerId && scope.customerIds.includes(ticket.customerId);
+  if (!hasAccess) return { ok: false, response: notFoundResponse(ticketId) };
+  return { ok: true, ticket };
+}
 
-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);
+// src/tools/ticket-attachments.ts
+async function findAttachment(attachmentId) {
+  const [ticketAtt] = await db.select({
+    ticketId: schema.ticketAttachments.ticketId,
+    fileName: schema.ticketAttachments.fileName,
+    fileSize: schema.ticketAttachments.fileSize,
+    mimeType: schema.ticketAttachments.mimeType,
+    storageKey: schema.ticketAttachments.storageKey
+  }).from(schema.ticketAttachments).where(eq(schema.ticketAttachments.id, attachmentId)).limit(1);
+  if (ticketAtt) return { ...ticketAtt, source: "ticket" };
+  const [commentAtt] = await db.select({
+    ticketId: schema.ticketCommentAttachments.ticketId,
+    fileName: schema.ticketCommentAttachments.fileName,
+    fileSize: schema.ticketCommentAttachments.fileSize,
+    mimeType: schema.ticketCommentAttachments.mimeType,
+    storageKey: schema.ticketCommentAttachments.storageKey
+  }).from(schema.ticketCommentAttachments).where(eq(schema.ticketCommentAttachments.id, attachmentId)).limit(1);
+  if (commentAtt) return { ...commentAtt, source: "comment" };
+  return null;
+}
+async function handleGetTicketAttachment(input) {
+  const { attachmentId } = input;
+  const attachment = await findAttachment(attachmentId);
+  if (!attachment) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Attachment not found: ${attachmentId}. Use get-ticket-by-id to list attachment ids.`
         }
-        if (consolidatedCount > 0) {
-          console.log(`\u{1F9F9} Cleaned up ${consolidatedCount} duplicate agenda entries for session ${aiSessionId}`);
+      ]
+    };
+  }
+  const access = await loadAccessibleTicket(input.teamId, attachment.ticketId);
+  if (!access.ok) return access.response;
+  let url;
+  try {
+    const signed = await storage.createSignedUrl({
+      bucket: "vault",
+      path: attachment.storageKey,
+      expiresIn: 3600
+    });
+    url = signed.url;
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to create a download URL for attachment ${attachmentId}: ${error instanceof Error ? error.message : String(error)}`
         }
-        let responseText = `\u{1F389} **AI Session Completed Successfully!**
-
-`;
-        responseText += `\u{1F194} Session: ${aiSessionId}
-`;
-        responseText += `\u{1F4CA} **Performance Summary:**
-`;
-        responseText += `   \u2022 Tasks Completed: ${workCompleted.length}
-`;
-        responseText += `   \u2022 Time Spent: ${timeSpentMinutes} minutes
-`;
-        responseText += `   \u2022 Estimated Time: ${session.ai_time_estimate_minutes || "N/A"} minutes
-`;
-        responseText += `   \u2022 Efficiency: ${efficiencyScore < 1 ? "\u{1F680}" : efficiencyScore > 1.5 ? "\u26A0\uFE0F" : "\u23F1\uFE0F"} ${(efficiencyScore * 100).toFixed(0)}%
-`;
-        responseText += `   \u2022 Session Duration: ${sessionDuration} minutes
+      ]
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F4CE} **${attachment.fileName}**
+Type: ${attachment.mimeType}
+Size: ${Math.round(attachment.fileSize / 1024)}KB
+Source: ${attachment.source} attachment
 
-`;
-        responseText += `\u2705 **Work Completed:**
-`;
-        workCompleted.forEach((task, index) => {
-          responseText += `${index + 1}. ${task}
-`;
-        });
-        responseText += `
-`;
-        if (technicalSummary) {
-          responseText += `\u{1F527} **Technical Summary:**
-${technicalSummary}
+Download URL (valid for 1 hour):
+${url}`
+      }
+    ]
+  };
+}
 
-`;
-        }
-        if (efficiencyNotes) {
-          responseText += `\u{1F4C8} **Efficiency Notes:**
-${efficiencyNotes}
+// src/tools/ticket-comments.ts
+init_auth();
+init_db();
 
+// src/tools/tiptap-text.ts
+function renderNode(node) {
+  if (!node) return "";
+  if (node.type === "text") return node.text ?? "";
+  if (node.type === "hardBreak") return "\n";
+  const inner = (node.content ?? []).map(renderNode).join("");
+  switch (node.type) {
+    case "paragraph":
+      return `${inner}
 `;
-        }
-        if (agendaEvent) {
-          responseText += `\u{1F4C5} **Timetrack Entry ${wasUpdated ? "Updated" : "Created"}:**
-`;
-          responseText += `   \u2022 Agenda event ${wasUpdated ? "updated with final" : "created with"} work summary
+    case "heading":
+      return `${inner}
 `;
-          responseText += `   \u2022 Status: DRAFT (requires approval in agenda)
+    case "listItem":
+      return `- ${inner.trimEnd()}
 `;
-          responseText += `   \u2022 Duration: ${estimatedMinutes} minutes
+    case "bulletList":
+    case "orderedList":
+      return inner;
+    case "blockquote":
+      return `${inner}
 `;
-          responseText += `   \u2022 Period: ${sessionStart.toLocaleString()} - ${completionTime.toLocaleString()}
+    default:
+      return inner;
+  }
+}
+function tiptapToPlainText(content) {
+  if (!content) return "";
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("{")) return content;
+  let doc;
+  try {
+    doc = JSON.parse(trimmed);
+  } catch {
+    return content;
+  }
+  if (doc?.type !== "doc" || !Array.isArray(doc.content)) return content;
+  return doc.content.map(renderNode).join("").trim();
+}
 
-`;
-        }
-        responseText += `\u{1F4CB} **Context for Customer Response:**
-`;
-        responseText += `   \u2022 Use "get-completion-context" to retrieve full context
-`;
-        responseText += `   \u2022 Generate customer-friendly response based on completed work
-`;
-        responseText += `   \u2022 Focus on business value and customer benefits
+// src/tools/ticket-comments.ts
+async function handleAddTicketComment(input) {
+  const ctx = authContext;
+  const isInternal = input.isInternal ?? false;
+  const access = await loadAccessibleTicket(input.teamId, input.ticketId);
+  if (!access.ok) return access.response;
+  const ticket = access.ticket;
+  const content = ensureTipTapFormat(input.content) ?? input.content;
+  const [comment] = await db.insert(schema.ticketComments).values({
+    ticketId: ticket.id,
+    teamId: ticket.teamId,
+    userId: ctx.userId,
+    content,
+    isInternal
+  }).returning({ id: schema.ticketComments.id });
+  await db.update(schema.tickets).set({ updatedAt: sql`NOW()`, updatedBy: ctx.userId }).where(eq(schema.tickets.id, ticket.id));
+  await db.insert(schema.ticketActivity).values({
+    ticketId: ticket.id,
+    teamId: ticket.teamId,
+    userId: ctx.userId,
+    activityType: isInternal ? "comment_internal_added" : "comment_added"
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Comment added to ${ticket.ticketNumber}**${isInternal ? " (internal)" : ""}
 
-`;
-        responseText += `\u{1F3AF} **Session archived successfully!**`;
-        return {
-          content: [{
-            type: "text",
-            text: responseText
-          }]
-        };
+Comment id: ${comment?.id}`
       }
-      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"}`);
+    ]
+  };
+}
+async function handleGetTicketComments(input) {
+  const access = await loadAccessibleTicket(input.teamId, input.ticketId);
+  if (!access.ok) return access.response;
+  const ticket = access.ticket;
+  const comments = await db.select({
+    id: schema.ticketComments.id,
+    content: schema.ticketComments.content,
+    isInternal: schema.ticketComments.isInternal,
+    createdAt: schema.ticketComments.createdAt,
+    userName: schema.ticketComments.userName,
+    authorName: schema.users.fullName
+  }).from(schema.ticketComments).leftJoin(schema.users, eq(schema.users.id, schema.ticketComments.userId)).where(eq(schema.ticketComments.ticketId, ticket.id)).orderBy(desc(schema.ticketComments.createdAt));
+  if (comments.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No comments on ticket ${ticket.ticketNumber}.`
         }
-        let responseText = `\u23F1\uFE0F **Hours ${wasUpdated ? "Added to Existing Entry" : "Logged Successfully"}!**
+      ]
+    };
+  }
+  const rendered = comments.map((c) => {
+    const author = c.authorName ?? c.userName ?? "Unknown";
+    const flag = c.isInternal ? " [internal]" : "";
+    const text = tiptapToPlainText(c.content) || "(empty)";
+    return `\u2022 ${author}${flag} \u2014 ${c.createdAt}
+${text}`;
+  }).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u{1F4AC} **Comments on ${ticket.ticketNumber}** (${comments.length})
 
-`;
-        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
+${rendered}`
+      }
+    ]
+  };
+}
 
-`;
-        }
-        if (consolidatedCount > 0) {
-          responseText += `\u{1F9F9} **Cleaned up ${consolidatedCount} duplicate entries**
+// src/tools/ticket-update.ts
+init_auth();
+init_db();
+async function handleUpdateTicket(input) {
+  const ctx = authContext;
+  const { id } = input;
+  const access = await loadAccessibleTicket(input.teamId, id);
+  if (!access.ok) return access.response;
+  const ticket = access.ticket;
+  if (input.assigneeId !== void 0 && input.assigneeId !== null) {
+    const member = await isUserTeamMember(input.assigneeId, ticket.teamId);
+    if (!member) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Cannot assign ticket: user ${input.assigneeId} is not a member of the ticket's team (${ticket.teamId}).`
+          }
+        ]
+      };
+    }
+  }
+  const updateValues = {
+    updatedAt: sql`NOW()`,
+    updatedBy: ctx.userId
+  };
+  if (input.title !== void 0) updateValues.title = input.title;
+  if (input.description !== void 0) {
+    updateValues.description = ensureTipTapFormat(input.description);
+  }
+  if (input.status !== void 0) {
+    updateValues.status = input.status;
+  }
+  if (input.priority !== void 0) {
+    updateValues.priority = input.priority;
+  }
+  if (input.type !== void 0) updateValues.type = input.type;
+  if (input.projectId !== void 0) updateValues.projectId = input.projectId;
+  if (input.customerId !== void 0) {
+    updateValues.customerId = input.customerId;
+  }
+  if (input.assigneeId !== void 0) {
+    updateValues.assigneeId = input.assigneeId;
+  }
+  if (input.estimatedHours !== void 0) {
+    updateValues.estimatedHours = input.estimatedHours;
+  }
+  await db.update(schema.tickets).set(updateValues).where(eq(schema.tickets.id, ticket.id));
+  const changes = [];
+  const activities = [];
+  if (input.status !== void 0 && input.status !== ticket.status) {
+    activities.push({
+      activityType: "status_changed",
+      oldValue: ticket.status,
+      newValue: input.status
+    });
+    changes.push(`status ${ticket.status} -> ${input.status}`);
+  }
+  if (input.priority !== void 0 && input.priority !== ticket.priority) {
+    activities.push({
+      activityType: "priority_changed",
+      oldValue: ticket.priority,
+      newValue: input.priority
+    });
+    changes.push(`priority ${ticket.priority} -> ${input.priority}`);
+  }
+  if (input.type !== void 0 && input.type !== ticket.type) {
+    activities.push({
+      activityType: "type_changed",
+      oldValue: ticket.type,
+      newValue: input.type
+    });
+    changes.push(`type ${ticket.type} -> ${input.type}`);
+  }
+  if (input.assigneeId !== void 0 && (input.assigneeId ?? null) !== ticket.assigneeId) {
+    activities.push({
+      activityType: "assignee_changed",
+      oldValue: ticket.assigneeId ?? void 0,
+      newValue: input.assigneeId ?? void 0
+    });
+    changes.push(
+      input.assigneeId ? `assigned to ${input.assigneeId}` : "unassigned"
+    );
+  }
+  if (input.title !== void 0 && input.title !== ticket.title) {
+    changes.push("title updated");
+  }
+  if (input.description !== void 0) changes.push("description updated");
+  if (input.projectId !== void 0) changes.push("project updated");
+  if (input.customerId !== void 0) changes.push("customer updated");
+  if (input.estimatedHours !== void 0) changes.push("estimated hours updated");
+  for (const activity of activities) {
+    await db.insert(schema.ticketActivity).values({
+      ticketId: ticket.id,
+      teamId: ticket.teamId,
+      userId: ctx.userId,
+      activityType: activity.activityType,
+      oldValue: activity.oldValue,
+      newValue: activity.newValue
+    });
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Ticket Updated: ${ticket.ticketNumber}**
 
-`;
-        }
-        responseText += `\u{1F4CB} **Entry Details:**
-`;
-        if (project) {
-          responseText += `   \u2022 Project: ${project.name}
-`;
-        } else {
-          responseText += `   \u2022 Project: (No project assigned)
-`;
-        }
-        if (ticket) {
-          responseText += `   \u2022 Ticket: ${ticket.title} (${ticket.status})
-`;
-        }
-        if (aiSession) {
-          responseText += `   \u2022 AI Session: ${aiSession.id} (${aiSession.status})
-`;
-        }
-        responseText += `   \u2022 Description: ${workDescription}
-`;
-        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 Entry ID: ${agendaEntry.id}
+${changes.length > 0 ? `Changes:
+${changes.map((c) => `   \u2022 ${c}`).join("\n")}` : "No field changes were applied."}`
+      }
+    ]
+  };
+}
 
-`;
-        if (chatContextSummary) {
-          responseText += `\u{1F4CA} **Work Context:**
-`;
-          responseText += `${chatContextSummary.substring(0, 200)}${chatContextSummary.length > 200 ? "..." : ""}
+// src/tools/tickets.ts
+init_auth();
+init_db();
+function isImageFile(mimeType) {
+  return mimeType.startsWith("image/") && ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"].includes(
+    mimeType
+  );
+}
+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;
+  }
+}
+async function handleGetTickets(input) {
+  const ctx = authContext;
+  const { status, priority, projectId, customerId, q, pageSize = 20 } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const teamIds = await getAccessibleTeamIds(teamId);
+  const projectIds = await getAccessibleProjectIds(ctx.userId, teamId);
+  const customerIds = await getAccessibleCustomerIds(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:
 
-`;
-        }
-        responseText += `\u2705 Time entry ${wasUpdated ? "updated" : "created"} and ready for review in the agenda!`;
-        return {
-          content: [{
-            type: "text",
-            text: responseText
-          }]
-        };
+${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."}`
       }
-      // === 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.`
-              }]
-            };
-          }
-          const content = Buffer.from(data.content, "base64").toString("utf-8");
-          let responseText = `\u{1F4C4} **File: ${filePath}**
-`;
-          responseText += `Repository: ${githubInfo.repositoryFullName}
+    ]
+  };
+}
+async function handleGetTicketById(input) {
+  const { id } = input;
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const { teamIds, projectIds, customerIds } = scope;
+  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 allAttachments = [
+    ...attachments.map((a) => ({
+      id: a.id,
+      fileName: a.fileName,
+      mimeType: a.mimeType,
+      fileSize: a.fileSize,
+      source: "ticket"
+    })),
+    ...commentAttachments.map((a) => ({
+      id: a.id,
+      fileName: a.fileName,
+      mimeType: a.mimeType,
+      fileSize: a.fileSize,
+      source: "comment"
+    }))
+  ];
+  const attachmentList = allAttachments.length > 0 ? `
+\u{1F4CE} **Attachments (${allAttachments.length})** \u2014 call get-ticket-attachment with the id for a download URL (images are also shown inline below):
+` + allAttachments.map(
+    (a) => `   \u2022 ${a.fileName} (${a.mimeType}, ${Math.round(
+      a.fileSize / 1024
+    )}KB) \u2014 id: ${a.id}${a.source === "comment" ? " [on a comment]" : ""}`
+  ).join("\n") + "\n" : "";
+  const commentList = comments.length > 0 ? `
+\u{1F4AC} **Comments (${comments.length})**:
+` + comments.map((c) => {
+    const author = c.userId ? commentUserMap.get(c.userId)?.fullName ?? "Unknown" : "Unknown";
+    const text = tiptapToPlainText(c.content) || "(empty)";
+    return `   \u2022 ${author} (${new Date(
+      c.createdAt
+    ).toLocaleDateString()}):
+${text.split("\n").map((l) => `     ${l}`).join("\n")}`;
+  }).join("\n") : "";
+  const requesterLine = ticketRow.requester ? `Requester (creator): ${ticketRow.requester.fullName || "Unknown"} [id: ${ticketRow.requester.id}]
+` : `Requester (creator): Unknown
 `;
-          responseText += `Size: ${data.size} bytes
+  const assigneeLine = ticketRow.assignee ? `Assignee: ${ticketRow.assignee.fullName || "Unknown"} [id: ${ticketRow.assignee.id}]
+` : ticketRow.requester ? `Assignee: (unassigned) \u2014 use requester id ${ticketRow.requester.id} for review handoff
+` : `Assignee: (unassigned)
 `;
-          responseText += `URL: ${data.html_url}
+  const content = [
+    {
+      type: "text",
+      text: `**Ticket Details:**
 
-`;
-          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"}`
-            }]
-          };
+**${ticketRow.ticketNumber}**: ${ticketRow.title}
+Ticket id: ${ticketRow.id}
+Team id: ${ticketRow.teamId}
+Status: ${ticketRow.status}
+Priority: ${ticketRow.priority}
+Type: ${ticketRow.type}
+${ticketRow.description ? `Description: ${tiptapToPlainText(ticketRow.description)}
+` : ""}${ticketRow.project?.name ? `Project: ${ticketRow.project.name}
+` : ""}${ticketRow.customer?.name ? `Customer: ${ticketRow.customer.name}
+` : ""}` + assigneeLine + requesterLine + `Created: ${new Date(ticketRow.createdAt).toLocaleDateString()}
+` + attachmentList + commentList
+    }
+  ];
+  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()})
+`
+          });
         }
       }
-      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 (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 ? "..." : ""}"
+` : "")
           });
-          if (!Array.isArray(data)) {
-            return {
-              content: [{
-                type: "text",
-                text: `\u274C "${directoryPath}" is not a directory.`
-              }]
-            };
-          }
-          let responseText = `\u{1F4C1} **Directory: ${directoryPath || "(root)"}**
-`;
-          responseText += `Repository: ${githubInfo.repositoryFullName}
-`;
-          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}):**
-`;
-            for (const dir of directories) {
-              responseText += `   - ${dir.name}/
-`;
-            }
-            responseText += `
-`;
-          }
-          if (files.length > 0) {
-            responseText += `**\u{1F4C4} Files (${files.length}):**
-`;
-            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}`);
     }
-  } 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));
-    return {
-      content: [{
+  }
+  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 resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  let resolvedTeamId = resolved.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) {
+        const member = await isUserTeamMember(ctx.userId, project.teamId);
+        if (!member) return notAMemberResponse(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);
+        }
+      }
+    }
+  }
+  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: `Error executing ${name}: ${message}`
-      }]
-    };
+        text: `\u2705 **Ticket Created Successfully!**
+
+Ticket Number: **${ticketNumber}**
+Title: ${title}
+Status: ${status}
+Priority: ${priority}
+Type: ${type}
+`
+      }
+    ]
+  };
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+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"
+  );
+  process.exit(1);
+}
+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;
+var server = new Server(
+  {
+    name: "mg-tickets-mcp-bridge",
+    version: "3.0.2"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
   }
-});
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  if (!authContext) {
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: RESOURCES
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { authContext: authContext2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  if (!authContext2) {
     return {
-      contents: [{
-        uri: request.params.uri,
-        mimeType: "text/plain",
-        text: "Error: Not authenticated. API key validation failed."
-      }]
+      content: [
+        {
+          type: "text",
+          text: "Error: Not authenticated. API key validation failed."
+        }
+      ]
     };
   }
-  const { uri } = request.params;
-  console.error(`\u{1F4DA} Reading resource: ${uri}`);
+  const { name, arguments: toolArgs } = request.params;
+  console.error(`\u{1F6E0}\uFE0F  Executing tool: ${name} for team ${authContext2.teamId}`);
   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;
-        return {
-          contents: [{
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(data, null, 2)
-          }]
-        };
-      }
-      case "customers://all": {
-        const customerIds = await getAccessibleCustomerIds(authContext.teamId);
-        if (customerIds.length === 0) {
-          return {
-            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;
-        return {
-          contents: [{
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(data, null, 2)
-          }]
-        };
-      }
-      case "projects://active": {
-        const projectIds = await getAccessibleProjectIds(authContext.userId, authContext.teamId);
-        if (projectIds.length === 0) {
-          return {
-            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;
-        return {
-          contents: [{
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(data, null, 2)
-          }]
-        };
-      }
+    switch (name) {
+      case "get-teams":
+        return await handleGetTeams();
+      case "get-tickets":
+        return await handleGetTickets(asToolArgs(toolArgs));
+      case "get-ticket-by-id":
+        return await handleGetTicketById(asToolArgs(toolArgs));
+      case "create-ticket":
+        return await handleCreateTicket(asToolArgs(toolArgs));
+      case "update-ticket":
+        return await handleUpdateTicket(asToolArgs(toolArgs));
+      case "add-ticket-comment":
+        return await handleAddTicketComment(
+          asToolArgs(toolArgs)
+        );
+      case "get-ticket-comments":
+        return await handleGetTicketComments(
+          asToolArgs(toolArgs)
+        );
+      case "get-ticket-attachment":
+        return await handleGetTicketAttachment(
+          asToolArgs(toolArgs)
+        );
+      case "get-customers":
+        return await handleGetCustomers(asToolArgs(toolArgs));
+      case "create-customer":
+        return await handleCreateCustomer(asToolArgs(toolArgs));
+      case "get-projects":
+        return await handleGetProjects(asToolArgs(toolArgs));
+      case "create-project":
+        return await handleCreateProject(asToolArgs(toolArgs));
+      case "start-ai-session-smart":
+        return await handleStartAiSession(
+          asToolArgs(toolArgs)
+        );
+      case "track-manual-follow-up":
+        return await handleTrackManualFollowUp(
+          asToolArgs(toolArgs)
+        );
+      case "get-session-context":
+        return await handleGetSessionContext(
+          asToolArgs(toolArgs)
+        );
+      case "sync-session-todos":
+        return await handleSyncSessionTodos(
+          asToolArgs(toolArgs)
+        );
+      case "add-follow-up-todos":
+        return await handleAddFollowUpTodos(
+          asToolArgs(toolArgs)
+        );
+      case "update-session-status":
+        return await handleUpdateSessionStatus(
+          asToolArgs(toolArgs)
+        );
+      case "get-completion-context":
+        return await handleGetCompletionContext(
+          asToolArgs(toolArgs)
+        );
+      case "save-customer-response":
+        return await handleSaveCustomerResponse(
+          asToolArgs(toolArgs)
+        );
+      case "complete-ai-session":
+        return await handleCompleteAiSession(
+          asToolArgs(toolArgs)
+        );
+      case "log-hours":
+        return await handleLogHours(asToolArgs(toolArgs));
+      case "get-github-file":
+        return await handleGetGithubFile(asToolArgs(toolArgs));
+      case "list-github-directory":
+        return await handleListGithubDirectory(
+          asToolArgs(toolArgs)
+        );
       default:
-        throw new Error(`Unknown resource: ${uri}`);
+        throw new Error(`Unknown tool: ${name}`);
     }
   } catch (error) {
-    console.error(`\u274C Resource read error:`, error);
+    console.error("\u274C Tool execution error:", error);
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error);
     return {
-      contents: [{
-        uri,
-        mimeType: "text/plain",
-        text: `Error reading ${uri}: ${error instanceof Error ? error.message : "Unknown error"}`
-      }]
+      content: [{ type: "text", text: `Error executing ${name}: ${message}` }]
     };
   }
 });
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  return await handleReadResource(request.params.uri);
+});
 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.");
+  const ctx = await validateApiKey(apiKey);
+  if (!ctx) {
+    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(`\u{1F4CB} Available scopes: ${authContext.scopes.join(", ")}`);
+  setAuthContext(ctx);
+  console.error(
+    `\u2705 Authenticated as user ${ctx.userId} in team ${ctx.teamId}`
+  );
+  console.error(`\u{1F4CB} Available scopes: ${ctx.scopes.join(", ")}`);
   console.error("\u{1F4E1} MCP Bridge Server ready for connections");
   const transport = new StdioServerTransport();
   await server.connect(transport);