@amplis/mcp-server 0.2.0

package/dist/index.js

@@ -0,0 +1,3758 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/lib/errors.ts
+import { ZodError } from "zod";
+var MCPNotFoundError = class extends Error {
+  constructor(entity, id) {
+    super(`${entity} ${id} not found`);
+    this.name = "MCPNotFoundError";
+  }
+};
+var MCPPermissionError = class extends Error {
+  constructor(action) {
+    super(`Permission denied: ${action}`);
+    this.name = "MCPPermissionError";
+  }
+};
+var MCPValidationError = class extends Error {
+  constructor(message) {
+    super(`Validation error: ${message}`);
+    this.name = "MCPValidationError";
+  }
+};
+var MCPAuthError = class extends Error {
+  constructor(message) {
+    super(`Authentication error: ${message}`);
+    this.name = "MCPAuthError";
+  }
+};
+var SENSITIVE_PATTERNS = [
+  /prisma/i,
+  /P\d{4}/,
+  // Prisma error codes (P2002, P2025, etc.)
+  /postgresql?:\/\//i,
+  // Connection strings
+  /at .*\.ts:\d+/,
+  // Stack trace lines
+  /FATAL|PANIC/,
+  // Postgres fatal errors
+  /relation ".*" does not exist/i,
+  // Table/relation names
+  /column ".*" of relation/i,
+  // Column constraint details
+  /unique constraint/i,
+  // Constraint names
+  /foreign key constraint/i,
+  // FK details
+  /violates .*constraint/i
+  // Generic constraint violations
+];
+var MAX_ERROR_LENGTH = 500;
+function sanitizeError(err) {
+  if (err instanceof MCPNotFoundError || err instanceof MCPPermissionError || err instanceof MCPValidationError || err instanceof MCPAuthError) {
+    return err.message;
+  }
+  if (err instanceof ZodError) {
+    const issues = err.issues.slice(0, 5).map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return `Validation error: ${issues}`;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  for (const pattern of SENSITIVE_PATTERNS) {
+    if (pattern.test(message)) {
+      return "An internal error occurred. Please try again or contact support.";
+    }
+  }
+  if (message.length > MAX_ERROR_LENGTH) {
+    return message.slice(0, MAX_ERROR_LENGTH) + "...";
+  }
+  return message;
+}
+
+// src/resources/projects.ts
+var projects_exports = {};
+__export(projects_exports, {
+  handleRead: () => handleRead,
+  resourceTemplates: () => resourceTemplates,
+  staticResources: () => staticResources
+});
+
+// src/lib/credentials.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CREDENTIALS_DIR = path.join(os.homedir(), ".amplis");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+function saveCredentials(data) {
+  if (!fs.existsSync(CREDENTIALS_DIR)) {
+    fs.mkdirSync(CREDENTIALS_DIR, { mode: 448, recursive: true });
+  }
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), {
+    mode: 384,
+    encoding: "utf-8"
+  });
+}
+function loadCredentials() {
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  if (process.platform !== "win32") {
+    try {
+      const stat = fs.statSync(CREDENTIALS_FILE);
+      const mode = stat.mode & 511;
+      if (mode & 63) {
+        console.error(
+          `WARNING: ${CREDENTIALS_FILE} has permissions ${mode.toString(8)}. It should be 600 (owner read/write only). Run: chmod 600 ${CREDENTIALS_FILE}`
+        );
+      }
+    } catch {
+    }
+  }
+  try {
+    const raw = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clearCredentials() {
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return false;
+  }
+  fs.unlinkSync(CREDENTIALS_FILE);
+  return true;
+}
+function getCredentialsPath() {
+  return CREDENTIALS_FILE;
+}
+
+// src/lib/api-client.ts
+var ApiError = class extends Error {
+  constructor(message, status, code, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "ApiError";
+  }
+};
+var cachedConfig = null;
+function getApiConfig() {
+  if (cachedConfig) return cachedConfig;
+  if (process.env.AMPLIS_API_URL && process.env.AMPLIS_API_KEY && process.env.AMPLIS_ORG_ID) {
+    cachedConfig = {
+      baseUrl: process.env.AMPLIS_API_URL,
+      apiKey: process.env.AMPLIS_API_KEY,
+      orgId: process.env.AMPLIS_ORG_ID
+    };
+    return cachedConfig;
+  }
+  const creds = loadCredentials();
+  if (!creds) {
+    throw new Error(
+      "No credentials found. Run `amplis-mcp login` to authenticate."
+    );
+  }
+  if (!creds.apiKey) {
+    throw new Error(
+      "No API key in credentials. Run `amplis-mcp login` to re-authenticate."
+    );
+  }
+  cachedConfig = {
+    baseUrl: process.env.AMPLIS_API_URL || "https://app.amplis.com.au",
+    apiKey: creds.apiKey,
+    orgId: creds.orgId
+  };
+  return cachedConfig;
+}
+async function mcpFetch(endpoint, options = {}) {
+  const config = getApiConfig();
+  const url = `${config.baseUrl}/api/mcp/v1${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json",
+      "X-MCP-Org-Id": config.orgId,
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    let errorData = {};
+    try {
+      errorData = await response.json();
+    } catch {
+    }
+    throw new ApiError(
+      errorData.message || `API request failed: ${response.status} ${response.statusText}`,
+      response.status,
+      errorData.code,
+      errorData.details
+    );
+  }
+  if (response.status === 204) {
+    return {};
+  }
+  return response.json();
+}
+async function apiGet(endpoint, params) {
+  let url = endpoint;
+  if (params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        searchParams.set(key, String(value));
+      }
+    }
+    const queryString = searchParams.toString();
+    if (queryString) {
+      url = `${endpoint}?${queryString}`;
+    }
+  }
+  return mcpFetch(url, { method: "GET" });
+}
+async function apiPost(endpoint, body) {
+  return mcpFetch(endpoint, {
+    method: "POST",
+    body: body ? JSON.stringify(body) : void 0
+  });
+}
+async function apiPatch(endpoint, body) {
+  return mcpFetch(endpoint, {
+    method: "PATCH",
+    body: body ? JSON.stringify(body) : void 0
+  });
+}
+
+// src/lib/response.ts
+function success(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function error(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }, null, 2) }],
+    isError: true
+  };
+}
+function safeError(err) {
+  return error(sanitizeError(err));
+}
+function resourceContent(uri, data) {
+  return {
+    contents: [
+      { uri, mimeType: "application/json", text: JSON.stringify(data, null, 2) }
+    ]
+  };
+}
+
+// src/resources/projects.ts
+var staticResources = [
+  { uri: "amplis://projects", name: "Projects", description: "List all projects with status, dates, and client", mimeType: "application/json" }
+];
+var resourceTemplates = [
+  { uriTemplate: "amplis://projects/{projectId}", name: "Project Detail", description: "Detailed project view with tasks, team, and deliverables", mimeType: "application/json" }
+];
+async function handleProjectsList() {
+  const result = await apiGet("/resources/projects");
+  return result.projects;
+}
+async function handleProjectDetail(projectId) {
+  return await apiGet(`/resources/projects/${projectId}`);
+}
+async function handleRead(uri) {
+  if (uri === "amplis://projects") return resourceContent(uri, await handleProjectsList());
+  const match = uri.match(/^amplis:\/\/projects\/([^/]+)$/);
+  if (match) return resourceContent(uri, await handleProjectDetail(match[1]));
+  return null;
+}
+
+// src/resources/pipeline.ts
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  handleRead: () => handleRead2,
+  resourceTemplates: () => resourceTemplates2,
+  staticResources: () => staticResources2
+});
+var staticResources2 = [
+  {
+    uri: "amplis://pipeline",
+    name: "Pipeline",
+    description: "Sales pipeline stages with project counts and values",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates2 = [];
+async function handlePipelineStages() {
+  const result = await apiGet("/resources/pipeline");
+  return result;
+}
+async function handleRead2(uri) {
+  if (uri === "amplis://pipeline") {
+    return resourceContent(uri, await handlePipelineStages());
+  }
+  return null;
+}
+
+// src/resources/alerts.ts
+var alerts_exports = {};
+__export(alerts_exports, {
+  handleRead: () => handleRead3,
+  resourceTemplates: () => resourceTemplates3,
+  staticResources: () => staticResources3
+});
+var staticResources3 = [
+  { uri: "amplis://alerts", name: "Alerts", description: "Active alerts requiring attention", mimeType: "application/json" }
+];
+var resourceTemplates3 = [];
+async function handleActiveAlerts() {
+  const result = await apiGet("/resources/alerts");
+  return result.alerts;
+}
+async function handleRead3(uri) {
+  if (uri === "amplis://alerts") return resourceContent(uri, await handleActiveAlerts());
+  return null;
+}
+
+// src/resources/utilization.ts
+var utilization_exports = {};
+__export(utilization_exports, {
+  handleRead: () => handleRead4,
+  resourceTemplates: () => resourceTemplates4,
+  staticResources: () => staticResources4
+});
+var staticResources4 = [
+  {
+    uri: "amplis://team/utilization",
+    name: "Team Utilization",
+    description: "Team members with allocated hours and timesheet totals for current week",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates4 = [];
+async function handleTeamUtilization() {
+  const result = await apiGet("/resources/team/utilization");
+  return result.team;
+}
+async function handleRead4(uri) {
+  if (uri === "amplis://team/utilization") {
+    return resourceContent(uri, await handleTeamUtilization());
+  }
+  return null;
+}
+
+// src/resources/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  handleRead: () => handleRead5,
+  resourceTemplates: () => resourceTemplates5,
+  staticResources: () => staticResources5
+});
+var staticResources5 = [
+  {
+    uri: "decisions://org",
+    name: "Organization Decisions",
+    description: "Recent decisions across the organization",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates5 = [
+  {
+    uriTemplate: "context://project/{projectId}",
+    name: "Project Context",
+    description: "Full project context including memories, recent decisions, and risks",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "context://client/{clientId}",
+    name: "Client Context",
+    description: "Full client context including preferences, relationship history, and projects",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "decisions://project/{projectId}",
+    name: "Project Decisions",
+    description: "Decision history for a project",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "meetings://project/{projectId}",
+    name: "Project Meetings",
+    description: "Meeting notes for a project",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "memories://search?q={query}",
+    name: "Memory Search",
+    description: "Search all memories semantically",
+    mimeType: "application/json"
+  }
+];
+async function handleProjectContext(projectId) {
+  const result = await apiGet(`/resources/context/project/${projectId}`);
+  return result;
+}
+async function handleClientContext(clientId) {
+  const result = await apiGet(`/resources/context/client/${clientId}`);
+  return result;
+}
+async function handleProjectDecisions(projectId) {
+  const result = await apiGet(`/resources/decisions/project/${projectId}`);
+  return result;
+}
+async function handleOrgDecisions() {
+  const result = await apiGet("/resources/decisions/org");
+  return result;
+}
+async function handleProjectMeetings(projectId) {
+  const result = await apiGet(`/resources/meetings/project/${projectId}`);
+  return result;
+}
+async function handleMemorySearch(query) {
+  const result = await apiGet("/resources/memories/search", { q: query });
+  return result;
+}
+async function handleRead5(uri) {
+  const projectContextMatch = uri.match(/^context:\/\/project\/(.+)$/);
+  if (projectContextMatch) {
+    return resourceContent(uri, await handleProjectContext(projectContextMatch[1]));
+  }
+  const clientContextMatch = uri.match(/^context:\/\/client\/(.+)$/);
+  if (clientContextMatch) {
+    return resourceContent(uri, await handleClientContext(clientContextMatch[1]));
+  }
+  const projectDecisionsMatch = uri.match(/^decisions:\/\/project\/(.+)$/);
+  if (projectDecisionsMatch) {
+    return resourceContent(uri, await handleProjectDecisions(projectDecisionsMatch[1]));
+  }
+  if (uri === "decisions://org") {
+    return resourceContent(uri, await handleOrgDecisions());
+  }
+  const projectMeetingsMatch = uri.match(/^meetings:\/\/project\/(.+)$/);
+  if (projectMeetingsMatch) {
+    return resourceContent(uri, await handleProjectMeetings(projectMeetingsMatch[1]));
+  }
+  const memorySearchMatch = uri.match(/^memories:\/\/search\?q=(.+)$/);
+  if (memorySearchMatch) {
+    const query = decodeURIComponent(memorySearchMatch[1]);
+    return resourceContent(uri, await handleMemorySearch(query));
+  }
+  return null;
+}
+
+// src/resources/clients.ts
+var clients_exports = {};
+__export(clients_exports, {
+  handleRead: () => handleRead6,
+  resourceTemplates: () => resourceTemplates6,
+  staticResources: () => staticResources6
+});
+var staticResources6 = [
+  { uri: "amplis://clients", name: "Clients", description: "List all clients", mimeType: "application/json" }
+];
+var resourceTemplates6 = [
+  { uriTemplate: "amplis://clients/{clientId}", name: "Client Detail", description: "Detailed client view", mimeType: "application/json" }
+];
+async function handleClientsList() {
+  const result = await apiGet("/resources/clients");
+  return result.clients;
+}
+async function handleClientDetail(clientId) {
+  return await apiGet(`/resources/clients/${clientId}`);
+}
+async function handleRead6(uri) {
+  if (uri === "amplis://clients") return resourceContent(uri, await handleClientsList());
+  const match = uri.match(/^amplis:\/\/clients\/([^/]+)$/);
+  if (match) return resourceContent(uri, await handleClientDetail(match[1]));
+  return null;
+}
+
+// src/resources/people.ts
+var people_exports = {};
+__export(people_exports, {
+  handleRead: () => handleRead7,
+  resourceTemplates: () => resourceTemplates7,
+  staticResources: () => staticResources7
+});
+var staticResources7 = [
+  { uri: "amplis://people", name: "People", description: "List all team members", mimeType: "application/json" }
+];
+var resourceTemplates7 = [
+  { uriTemplate: "amplis://people/{personId}", name: "Person Detail", description: "Detailed person view", mimeType: "application/json" }
+];
+async function handlePeopleList() {
+  const result = await apiGet("/resources/people");
+  return result.people;
+}
+async function handlePersonDetail(personId) {
+  return await apiGet(`/resources/people/${personId}`);
+}
+async function handleRead7(uri) {
+  if (uri === "amplis://people") return resourceContent(uri, await handlePeopleList());
+  const match = uri.match(/^amplis:\/\/people\/([^/]+)$/);
+  if (match) return resourceContent(uri, await handlePersonDetail(match[1]));
+  return null;
+}
+
+// src/resources/tasks.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  handleRead: () => handleRead8,
+  resourceTemplates: () => resourceTemplates8,
+  staticResources: () => staticResources8
+});
+var staticResources8 = [];
+var resourceTemplates8 = [
+  { uriTemplate: "amplis://projects/{projectId}/tasks", name: "Project Tasks", description: "All tasks for a project", mimeType: "application/json" }
+];
+async function handleProjectTasks(projectId) {
+  return await apiGet(`/resources/projects/${projectId}/tasks`);
+}
+async function handleRead8(uri) {
+  const match = uri.match(/^amplis:\/\/projects\/([^/]+)\/tasks$/);
+  if (match) return resourceContent(uri, await handleProjectTasks(match[1]));
+  return null;
+}
+
+// src/resources/deliverables.ts
+var deliverables_exports = {};
+__export(deliverables_exports, {
+  handleRead: () => handleRead9,
+  resourceTemplates: () => resourceTemplates9,
+  staticResources: () => staticResources9
+});
+var staticResources9 = [];
+var resourceTemplates9 = [
+  {
+    uriTemplate: "amplis://projects/{projectId}/deliverables",
+    name: "Project Deliverables",
+    description: "All deliverables for a project with status and progress",
+    mimeType: "application/json"
+  }
+];
+async function handleProjectDeliverables(projectId) {
+  const result = await apiGet(`/resources/projects/${projectId}/deliverables`);
+  return result;
+}
+async function handleRead9(uri) {
+  const match = uri.match(/^amplis:\/\/projects\/([^/]+)\/deliverables$/);
+  if (match) {
+    return resourceContent(uri, await handleProjectDeliverables(match[1]));
+  }
+  return null;
+}
+
+// src/resources/documents.ts
+var documents_exports = {};
+__export(documents_exports, {
+  handleRead: () => handleRead10,
+  resourceTemplates: () => resourceTemplates10,
+  staticResources: () => staticResources10
+});
+var staticResources10 = [
+  {
+    uri: "amplis://documents",
+    name: "Documents",
+    description: "List all documents (proposals, reports, resumes)",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates10 = [
+  {
+    uriTemplate: "amplis://documents/{documentId}",
+    name: "Document Detail",
+    description: "Document metadata and version history",
+    mimeType: "application/json"
+  }
+];
+async function handleDocumentsList() {
+  const result = await apiGet("/resources/documents");
+  return result.documents;
+}
+async function handleDocumentDetail(documentId) {
+  const document = await apiGet(`/resources/documents/${documentId}`);
+  return document;
+}
+async function handleRead10(uri) {
+  if (uri === "amplis://documents") {
+    return resourceContent(uri, await handleDocumentsList());
+  }
+  const match = uri.match(/^amplis:\/\/documents\/([^/]+)$/);
+  if (match) {
+    return resourceContent(uri, await handleDocumentDetail(match[1]));
+  }
+  return null;
+}
+
+// src/resources/knowledge.ts
+var knowledge_exports = {};
+__export(knowledge_exports, {
+  handleRead: () => handleRead11,
+  resourceTemplates: () => resourceTemplates11,
+  staticResources: () => staticResources11
+});
+var staticResources11 = [
+  {
+    uri: "amplis://knowledge/sources",
+    name: "Knowledge Base Sources",
+    description: "List all knowledge base sources with status and chunk counts",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates11 = [
+  {
+    uriTemplate: "amplis://knowledge/search?q={query}",
+    name: "Knowledge Base Search",
+    description: "Semantic search across knowledge base chunks",
+    mimeType: "application/json"
+  }
+];
+async function handleKBSourcesList() {
+  const result = await apiGet("/resources/knowledge/sources");
+  return result.sources;
+}
+async function handleKBSearch(query) {
+  const result = await apiGet("/resources/knowledge/search", { q: query });
+  return result;
+}
+async function handleRead11(uri) {
+  if (uri === "amplis://knowledge/sources") {
+    return resourceContent(uri, await handleKBSourcesList());
+  }
+  const match = uri.match(/^amplis:\/\/knowledge\/search\?q=(.+)$/);
+  if (match) {
+    const query = decodeURIComponent(match[1]);
+    return resourceContent(uri, await handleKBSearch(query));
+  }
+  return null;
+}
+
+// src/resources/credentials.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  handleRead: () => handleRead12,
+  resourceTemplates: () => resourceTemplates12,
+  staticResources: () => staticResources12
+});
+var staticResources12 = [
+  {
+    uri: "amplis://credentials",
+    name: "Credentials",
+    description: "List all credentials across the organization",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates12 = [
+  {
+    uriTemplate: "amplis://people/{personId}/credentials",
+    name: "Person Credentials",
+    description: "All credentials for a specific person",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "amplis://credentials/expiring?days={days}",
+    name: "Expiring Credentials",
+    description: "Credentials expiring within specified days",
+    mimeType: "application/json"
+  }
+];
+async function handleCredentialsList() {
+  const result = await apiGet("/resources/credentials");
+  return result.credentials;
+}
+async function handlePersonCredentials(personId) {
+  const result = await apiGet(`/resources/people/${personId}/credentials`);
+  return result;
+}
+async function handleExpiringCredentials(days) {
+  const result = await apiGet(`/resources/credentials/expiring`, { days });
+  return result;
+}
+async function handleRead12(uri) {
+  if (uri === "amplis://credentials") {
+    return resourceContent(uri, await handleCredentialsList());
+  }
+  const personMatch = uri.match(/^amplis:\/\/people\/([^/]+)\/credentials$/);
+  if (personMatch) {
+    return resourceContent(uri, await handlePersonCredentials(personMatch[1]));
+  }
+  const expiringMatch = uri.match(/^amplis:\/\/credentials\/expiring\?days=(\d+)$/);
+  if (expiringMatch) {
+    return resourceContent(uri, await handleExpiringCredentials(parseInt(expiringMatch[1], 10)));
+  }
+  return null;
+}
+
+// src/resources/capabilities.ts
+var capabilities_exports = {};
+__export(capabilities_exports, {
+  handleRead: () => handleRead13,
+  resourceTemplates: () => resourceTemplates13,
+  staticResources: () => staticResources13
+});
+var staticResources13 = [
+  { uri: "amplis://capabilities/matrix", name: "Capability Matrix", description: "Full capability matrix", mimeType: "application/json" }
+];
+var resourceTemplates13 = [
+  { uriTemplate: "amplis://people/{personId}/capabilities", name: "Person Capabilities", description: "Capabilities for a specific person", mimeType: "application/json" }
+];
+async function handleCapabilityMatrix() {
+  return await apiGet("/resources/capabilities/matrix");
+}
+async function handlePersonCapabilities(personId) {
+  return await apiGet(`/resources/people/${personId}/capabilities`);
+}
+async function handleRead13(uri) {
+  if (uri === "amplis://capabilities/matrix") return resourceContent(uri, await handleCapabilityMatrix());
+  const personMatch = uri.match(/^amplis:\/\/people\/([^/]+)\/capabilities$/);
+  if (personMatch) return resourceContent(uri, await handlePersonCapabilities(personMatch[1]));
+  return null;
+}
+
+// src/resources/availability.ts
+var availability_exports = {};
+__export(availability_exports, {
+  handleRead: () => handleRead14,
+  resourceTemplates: () => resourceTemplates14,
+  staticResources: () => staticResources14
+});
+var staticResources14 = [
+  { uri: "amplis://team/availability", name: "Team Availability", description: "Team availability overview for the next 4 weeks", mimeType: "application/json" }
+];
+var resourceTemplates14 = [
+  { uriTemplate: "amplis://people/{personId}/availability", name: "Person Availability", description: "Day-by-day availability for a person", mimeType: "application/json" }
+];
+async function handleTeamAvailability() {
+  const result = await apiGet("/resources/team/availability");
+  return result.team;
+}
+async function handlePersonAvailability(personId) {
+  return await apiGet(`/resources/people/${personId}/availability`);
+}
+async function handleRead14(uri) {
+  if (uri === "amplis://team/availability") return resourceContent(uri, await handleTeamAvailability());
+  const personMatch = uri.match(/^amplis:\/\/people\/([^/]+)\/availability$/);
+  if (personMatch) return resourceContent(uri, await handlePersonAvailability(personMatch[1]));
+  return null;
+}
+
+// src/resources/contacts.ts
+var contacts_exports = {};
+__export(contacts_exports, {
+  handleRead: () => handleRead15,
+  resourceTemplates: () => resourceTemplates15,
+  staticResources: () => staticResources15
+});
+var staticResources15 = [
+  { uri: "amplis://contacts", name: "Contacts", description: "List all global contacts", mimeType: "application/json" }
+];
+var resourceTemplates15 = [
+  { uriTemplate: "amplis://contacts/{contactId}", name: "Contact Detail", description: "Detailed contact information", mimeType: "application/json" }
+];
+async function handleContactsList() {
+  const result = await apiGet("/resources/contacts");
+  return result.contacts;
+}
+async function handleContactDetail(contactId) {
+  return await apiGet(`/resources/contacts/${contactId}`);
+}
+async function handleRead15(uri) {
+  if (uri === "amplis://contacts") return resourceContent(uri, await handleContactsList());
+  const match = uri.match(/^amplis:\/\/contacts\/([^/]+)$/);
+  if (match) return resourceContent(uri, await handleContactDetail(match[1]));
+  return null;
+}
+
+// src/resources/timesheets.ts
+var timesheets_exports = {};
+__export(timesheets_exports, {
+  handleRead: () => handleRead16,
+  resourceTemplates: () => resourceTemplates16,
+  staticResources: () => staticResources16
+});
+var staticResources16 = [
+  {
+    uri: "amplis://timesheets",
+    name: "Timesheets",
+    description: "Current timesheet periods across the team",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates16 = [
+  {
+    uriTemplate: "amplis://timesheets/{periodId}/entries",
+    name: "Timesheet Entries",
+    description: "All entries for a timesheet period",
+    mimeType: "application/json"
+  }
+];
+async function handleTimesheetsList() {
+  const result = await apiGet("/resources/timesheets");
+  return result.periods;
+}
+async function handleTimesheetEntries(periodId) {
+  const result = await apiGet(`/resources/timesheets/${periodId}/entries`);
+  return result;
+}
+async function handleRead16(uri) {
+  if (uri === "amplis://timesheets") {
+    return resourceContent(uri, await handleTimesheetsList());
+  }
+  const match = uri.match(/^amplis:\/\/timesheets\/([^/]+)\/entries$/);
+  if (match) {
+    return resourceContent(uri, await handleTimesheetEntries(match[1]));
+  }
+  return null;
+}
+
+// src/resources/invoices.ts
+var invoices_exports = {};
+__export(invoices_exports, {
+  handleRead: () => handleRead17,
+  resourceTemplates: () => resourceTemplates17,
+  staticResources: () => staticResources17
+});
+var staticResources17 = [
+  {
+    uri: "amplis://invoices",
+    name: "Invoices",
+    description: "List all invoices with status and amounts",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates17 = [
+  {
+    uriTemplate: "amplis://invoices/{invoiceId}",
+    name: "Invoice Detail",
+    description: "Detailed invoice with line items",
+    mimeType: "application/json"
+  }
+];
+async function handleInvoicesList() {
+  const result = await apiGet("/resources/invoices");
+  return result.invoices;
+}
+async function handleInvoiceDetail(invoiceId) {
+  const invoice = await apiGet(`/resources/invoices/${invoiceId}`);
+  return invoice;
+}
+async function handleRead17(uri) {
+  if (uri === "amplis://invoices") {
+    return resourceContent(uri, await handleInvoicesList());
+  }
+  const match = uri.match(/^amplis:\/\/invoices\/([^/]+)$/);
+  if (match) {
+    return resourceContent(uri, await handleInvoiceDetail(match[1]));
+  }
+  return null;
+}
+
+// src/resources/files.ts
+var files_exports = {};
+__export(files_exports, {
+  handleRead: () => handleRead18,
+  resourceTemplates: () => resourceTemplates18,
+  staticResources: () => staticResources18
+});
+var staticResources18 = [
+  {
+    uri: "amplis://files",
+    name: "Files",
+    description: "List all files and attachments",
+    mimeType: "application/json"
+  }
+];
+var resourceTemplates18 = [
+  {
+    uriTemplate: "amplis://files/{entityType}/{entityId}",
+    name: "Entity Files",
+    description: "Files attached to a specific entity",
+    mimeType: "application/json"
+  }
+];
+async function handleFilesList() {
+  const result = await apiGet("/resources/files");
+  return result.files;
+}
+async function handleEntityFiles(entityType, entityId) {
+  const result = await apiGet(`/resources/files/${entityType}/${entityId}`);
+  return result;
+}
+async function handleRead18(uri) {
+  if (uri === "amplis://files") {
+    return resourceContent(uri, await handleFilesList());
+  }
+  const match = uri.match(/^amplis:\/\/files\/([^/]+)\/([^/]+)$/);
+  if (match) {
+    return resourceContent(uri, await handleEntityFiles(match[1], match[2]));
+  }
+  return null;
+}
+
+// src/resources/index.ts
+var modules = [
+  projects_exports,
+  pipeline_exports,
+  alerts_exports,
+  utilization_exports,
+  memory_exports,
+  clients_exports,
+  people_exports,
+  tasks_exports,
+  deliverables_exports,
+  documents_exports,
+  knowledge_exports,
+  credentials_exports,
+  capabilities_exports,
+  availability_exports,
+  contacts_exports,
+  timesheets_exports,
+  invoices_exports,
+  files_exports
+];
+var resources = modules.flatMap((m) => [...m.staticResources]);
+var resourceTemplates19 = modules.flatMap((m) => [...m.resourceTemplates]);
+async function handleReadResource(uri) {
+  for (const mod of modules) {
+    const result = await mod.handleRead(uri);
+    if (result) return result;
+  }
+  throw new MCPNotFoundError("Resource", uri);
+}
+
+// src/lib/rate-limit.ts
+var WINDOW_MS = 6e4;
+var buckets = {
+  global: { timestamps: [], maxRequests: 120, windowMs: WINDOW_MS },
+  write: { timestamps: [], maxRequests: 30, windowMs: WINDOW_MS }
+};
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "task_create",
+  "task_update",
+  "time_log",
+  "timesheet_submit",
+  "note_add",
+  "pipeline_move",
+  "alert_acknowledge",
+  "site_visit_log",
+  "compliance_update",
+  "client_create",
+  "client_update",
+  "document_create",
+  "credential_create",
+  "credential_update",
+  "capability_add",
+  "capability_update",
+  "capability_evidence_add",
+  "availability_set",
+  "availability_bulk_set",
+  "contact_create",
+  "deliverable_create",
+  "deliverable_update",
+  "memory_store",
+  "decision_log",
+  "meeting_summarize"
+]);
+function pruneAndCheck(bucket, now) {
+  const cutoff = now - bucket.windowMs;
+  bucket.timestamps = bucket.timestamps.filter((t) => t > cutoff);
+  if (bucket.timestamps.length >= bucket.maxRequests) {
+    return false;
+  }
+  bucket.timestamps.push(now);
+  return true;
+}
+var RateLimitError = class extends Error {
+  constructor(bucket) {
+    super(`Rate limit exceeded (${bucket}). Please wait before making more requests.`);
+    this.name = "RateLimitError";
+  }
+};
+function checkRateLimit(toolName) {
+  const now = Date.now();
+  if (!pruneAndCheck(buckets.global, now)) {
+    throw new RateLimitError("global: 120 calls/minute");
+  }
+  if (WRITE_TOOLS.has(toolName)) {
+    if (!pruneAndCheck(buckets.write, now)) {
+      throw new RateLimitError("write: 30 calls/minute");
+    }
+  }
+}
+
+// src/tools/task-tools.ts
+var task_tools_exports = {};
+__export(task_tools_exports, {
+  handleToolCall: () => handleToolCall,
+  tools: () => tools
+});
+import { z as z2 } from "zod";
+
+// src/lib/schema-utils.ts
+import { z } from "zod";
+function caseInsensitiveEnum(values) {
+  const lowercaseMap = /* @__PURE__ */ new Map();
+  for (const v of values) {
+    lowercaseMap.set(v.toLowerCase(), v);
+  }
+  return z.string().transform((val, ctx) => {
+    const normalized = lowercaseMap.get(val.toLowerCase());
+    if (normalized === void 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.invalid_enum_value,
+        options: [...values],
+        received: val
+      });
+      return z.NEVER;
+    }
+    return normalized;
+  });
+}
+function caseInsensitiveEnumOptional(values) {
+  return caseInsensitiveEnum(values).optional();
+}
+
+// src/tools/task-tools.ts
+var TaskCreateSchema = z2.object({
+  projectId: z2.string(),
+  title: z2.string(),
+  description: z2.string().optional(),
+  assigneeId: z2.string().optional(),
+  dueDate: z2.string().optional(),
+  priority: caseInsensitiveEnumOptional(["low", "medium", "high", "critical"])
+});
+var TaskUpdateSchema = z2.object({
+  taskId: z2.string(),
+  status: caseInsensitiveEnumOptional(["not_started", "in_progress", "completed", "blocked"]),
+  assigneeId: z2.string().optional(),
+  dueDate: z2.string().optional(),
+  notes: z2.string().optional()
+});
+var TaskSearchSchema = z2.object({
+  projectId: z2.string().optional(),
+  status: caseInsensitiveEnumOptional(["not_started", "in_progress", "completed", "blocked"]),
+  assigneeId: z2.string().optional(),
+  overdue: z2.boolean().optional(),
+  query: z2.string().optional(),
+  limit: z2.number().optional()
+});
+var tools = [
+  {
+    name: "task_create",
+    description: "Create a new task in a project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: { type: "string", description: "Project ID" },
+        title: { type: "string", description: "Task title" },
+        description: { type: "string", description: "Task description" },
+        assigneeId: { type: "string", description: "Assignee person ID (optional)" },
+        dueDate: { type: "string", description: "Due date in ISO format (optional)" },
+        priority: { type: "string", enum: ["low", "medium", "high", "critical"], description: "Task priority" }
+      },
+      required: ["projectId", "title"]
+    }
+  },
+  {
+    name: "task_update",
+    description: "Update an existing task",
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskId: { type: "string", description: "Task ID" },
+        status: { type: "string", enum: ["not_started", "in_progress", "completed", "blocked"], description: "Task status" },
+        assigneeId: { type: "string", description: "New assignee ID" },
+        dueDate: { type: "string", description: "New due date" },
+        notes: { type: "string", description: "Notes to add" }
+      },
+      required: ["taskId"]
+    }
+  },
+  {
+    name: "task_search",
+    description: "Search tasks by status, assignee, project, or overdue",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: { type: "string", description: "Filter by project ID" },
+        status: { type: "string", enum: ["not_started", "in_progress", "completed", "blocked"], description: "Filter by status" },
+        assigneeId: { type: "string", description: "Filter by assignee person ID" },
+        overdue: { type: "boolean", description: "Only show overdue tasks" },
+        query: { type: "string", description: "Search task names" },
+        limit: { type: "number", description: "Max results (default 50)" }
+      }
+    }
+  }
+];
+async function handleTaskCreate(args) {
+  const input = TaskCreateSchema.parse(args);
+  const task = await apiPost("/tasks", {
+    projectId: input.projectId,
+    title: input.title,
+    description: input.description,
+    assigneeId: input.assigneeId,
+    dueDate: input.dueDate,
+    priority: input.priority
+  });
+  return { id: task.id, name: task.name, status: task.status, projectId: task.projectId };
+}
+async function handleTaskUpdate(args) {
+  const input = TaskUpdateSchema.parse(args);
+  const task = await apiPatch(`/tasks/${input.taskId}`, {
+    status: input.status,
+    assigneeId: input.assigneeId,
+    dueDate: input.dueDate,
+    notes: input.notes
+  });
+  return { id: task.id, name: task.name, status: task.status };
+}
+async function handleTaskSearch(args) {
+  const input = TaskSearchSchema.parse(args);
+  const result = await apiGet("/tasks", {
+    projectId: input.projectId,
+    status: input.status,
+    assigneeId: input.assigneeId,
+    overdue: input.overdue,
+    query: input.query,
+    limit: input.limit ?? 50
+  });
+  return {
+    count: result.count,
+    tasks: result.tasks.map((t) => ({
+      id: t.id,
+      name: t.name,
+      status: t.status,
+      startDate: t.startDate,
+      endDate: t.endDate,
+      isOverdue: new Date(t.endDate) < /* @__PURE__ */ new Date() && t.status !== "COMPLETED",
+      project: t.project,
+      assignees: t.assignees || []
+    }))
+  };
+}
+async function handleToolCall(name, args) {
+  try {
+    switch (name) {
+      case "task_create":
+        return success(await handleTaskCreate(args));
+      case "task_update":
+        return success(await handleTaskUpdate(args));
+      case "task_search":
+        return success(await handleTaskSearch(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/time-tools.ts
+var time_tools_exports = {};
+__export(time_tools_exports, {
+  handleToolCall: () => handleToolCall2,
+  tools: () => tools2
+});
+import { z as z3 } from "zod";
+var TimeLogSchema = z3.object({ projectId: z3.string(), taskId: z3.string().optional(), hours: z3.number().positive(), date: z3.string(), description: z3.string().optional(), category: caseInsensitiveEnumOptional(["billable", "internal", "leave"]) });
+var TimesheetSubmitSchema = z3.object({ periodId: z3.string() });
+var tools2 = [
+  { name: "time_log", description: "Log time against a project or task", inputSchema: { type: "object", properties: { projectId: { type: "string" }, taskId: { type: "string" }, hours: { type: "number" }, date: { type: "string" }, description: { type: "string" }, category: { type: "string", enum: ["billable", "internal", "leave"] } }, required: ["projectId", "hours", "date"] } },
+  { name: "timesheet_submit", description: "Submit a timesheet period for approval", inputSchema: { type: "object", properties: { periodId: { type: "string" } }, required: ["periodId"] } }
+];
+async function handleTimeLog(args) {
+  const input = TimeLogSchema.parse(args);
+  return await apiPost("/timesheets/entries", { ...input, category: input.category || "billable" });
+}
+async function handleTimesheetSubmit(args) {
+  const input = TimesheetSubmitSchema.parse(args);
+  return await apiPatch(`/timesheets/periods/${input.periodId}/submit`, {});
+}
+async function handleToolCall2(name, args) {
+  try {
+    switch (name) {
+      case "time_log":
+        return success(await handleTimeLog(args));
+      case "timesheet_submit":
+        return success(await handleTimesheetSubmit(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/note-tools.ts
+var note_tools_exports = {};
+__export(note_tools_exports, {
+  handleToolCall: () => handleToolCall3,
+  tools: () => tools3
+});
+import { z as z4 } from "zod";
+var NoteAddSchema = z4.object({ entityType: caseInsensitiveEnum(["project", "task", "client", "opportunity"]), entityId: z4.string(), content: z4.string(), category: caseInsensitiveEnumOptional(["general", "risk", "decision", "action"]) });
+var tools3 = [
+  { name: "note_add", description: "Add a note to a project, task, or client", inputSchema: { type: "object", properties: { entityType: { type: "string", enum: ["project", "task", "client", "opportunity"] }, entityId: { type: "string" }, content: { type: "string" }, category: { type: "string", enum: ["general", "risk", "decision", "action"] } }, required: ["entityType", "entityId", "content"] } }
+];
+async function handleNoteAdd(args) {
+  const input = NoteAddSchema.parse(args);
+  return await apiPost("/notes", { ...input, category: input.category || "general" });
+}
+async function handleToolCall3(name, args) {
+  try {
+    switch (name) {
+      case "note_add":
+        return success(await handleNoteAdd(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/pipeline-tools.ts
+var pipeline_tools_exports = {};
+__export(pipeline_tools_exports, {
+  handleToolCall: () => handleToolCall4,
+  tools: () => tools4
+});
+import { z as z5 } from "zod";
+var PipelineMoveSchema = z5.object({ opportunityId: z5.string(), stage: caseInsensitiveEnum(["lead", "discovery", "qualified", "proposal_draft", "proposal_submitted", "negotiation", "won", "lost"]), notes: z5.string().optional() });
+var tools4 = [
+  { name: "pipeline_move", description: "Move an opportunity to a different pipeline stage", inputSchema: { type: "object", properties: { opportunityId: { type: "string" }, stage: { type: "string", enum: ["lead", "discovery", "qualified", "proposal_draft", "proposal_submitted", "negotiation", "won", "lost"] }, notes: { type: "string" } }, required: ["opportunityId", "stage"] } }
+];
+async function handlePipelineMove(args) {
+  const input = PipelineMoveSchema.parse(args);
+  return await apiPatch(`/pipeline/${input.opportunityId}/stage`, input);
+}
+async function handleToolCall4(name, args) {
+  try {
+    switch (name) {
+      case "pipeline_move":
+        return success(await handlePipelineMove(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/alert-tools.ts
+var alert_tools_exports = {};
+__export(alert_tools_exports, {
+  handleToolCall: () => handleToolCall5,
+  tools: () => tools5
+});
+import { z as z6 } from "zod";
+var AlertAckSchema = z6.object({
+  alertId: z6.string(),
+  notes: z6.string().optional()
+});
+var tools5 = [
+  {
+    name: "alert_acknowledge",
+    description: "Acknowledge an alert",
+    inputSchema: {
+      type: "object",
+      properties: {
+        alertId: { type: "string", description: "Alert ID" },
+        notes: { type: "string", description: "Acknowledgment notes" }
+      },
+      required: ["alertId"]
+    }
+  }
+];
+async function handleAlertAcknowledge(args) {
+  const input = AlertAckSchema.parse(args);
+  const result = await apiPatch(`/alerts/${input.alertId}/acknowledge`, { notes: input.notes });
+  return { id: result.alert.id, title: result.alert.title, previousStatus: result.previousStatus, newStatus: result.alert.status };
+}
+async function handleToolCall5(name, args) {
+  try {
+    switch (name) {
+      case "alert_acknowledge":
+        return success(await handleAlertAcknowledge(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/compliance-tools.ts
+var compliance_tools_exports = {};
+__export(compliance_tools_exports, {
+  handleToolCall: () => handleToolCall6,
+  tools: () => tools6
+});
+import { z as z7 } from "zod";
+var SiteVisitLogSchema = z7.object({
+  projectId: z7.string(),
+  visitDate: z7.string(),
+  location: z7.string(),
+  findings: z7.array(z7.object({ observation: z7.string(), category: z7.string().optional(), severity: z7.string().optional() })).optional(),
+  risks: z7.array(z7.object({ description: z7.string(), severity: z7.string().optional(), mitigation: z7.string().optional() })).optional(),
+  actionItems: z7.array(z7.object({ task: z7.string(), owner: z7.string().optional(), dueDate: z7.string().optional() })).optional()
+});
+var ComplianceUpdateSchema = z7.object({
+  complianceId: z7.string(),
+  status: caseInsensitiveEnumOptional(["valid", "expiring_soon", "expired", "pending"]),
+  expiryDate: z7.string().optional(),
+  notes: z7.string().optional()
+});
+var tools6 = [
+  { name: "site_visit_log", description: "Log a site visit with findings and risks", inputSchema: { type: "object", properties: { projectId: { type: "string" }, visitDate: { type: "string" }, location: { type: "string" }, findings: { type: "array" }, risks: { type: "array" }, actionItems: { type: "array" } }, required: ["projectId", "visitDate", "location"] } },
+  { name: "compliance_update", description: "Update a compliance item", inputSchema: { type: "object", properties: { complianceId: { type: "string" }, status: { type: "string" }, expiryDate: { type: "string" }, notes: { type: "string" } }, required: ["complianceId"] } }
+];
+async function handleSiteVisitLog(args) {
+  const input = SiteVisitLogSchema.parse(args);
+  return await apiPost("/compliance/site-visits", input);
+}
+async function handleComplianceUpdate(args) {
+  const input = ComplianceUpdateSchema.parse(args);
+  const updated = await apiPatch(`/compliance/${input.complianceId}`, input);
+  return { id: updated.id, name: updated.name, status: updated.status };
+}
+async function handleToolCall6(name, args) {
+  try {
+    switch (name) {
+      case "site_visit_log":
+        return success(await handleSiteVisitLog(args));
+      case "compliance_update":
+        return success(await handleComplianceUpdate(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/client-tools.ts
+var client_tools_exports = {};
+__export(client_tools_exports, {
+  handleToolCall: () => handleToolCall7,
+  tools: () => tools7
+});
+import { z as z8 } from "zod";
+var ClientSearchSchema = z8.object({
+  query: z8.string().optional(),
+  industry: z8.string().optional(),
+  limit: z8.number().optional()
+});
+var ClientCreateSchema = z8.object({
+  name: z8.string(),
+  industry: z8.string().optional(),
+  website: z8.string().optional(),
+  description: z8.string().optional(),
+  primaryContactName: z8.string().optional(),
+  primaryContactEmail: z8.string().optional(),
+  primaryContactPhone: z8.string().optional()
+});
+var ClientUpdateSchema = z8.object({
+  clientId: z8.string(),
+  name: z8.string().optional(),
+  industry: z8.string().optional(),
+  website: z8.string().optional(),
+  description: z8.string().optional(),
+  healthScore: z8.number().optional(),
+  primaryContactName: z8.string().optional(),
+  primaryContactEmail: z8.string().optional(),
+  primaryContactPhone: z8.string().optional()
+});
+var tools7 = [
+  {
+    name: "client_search",
+    description: "Search clients by name or industry",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search client names" },
+        industry: { type: "string", description: "Filter by industry" },
+        limit: { type: "number", description: "Max results (default 20)" }
+      }
+    }
+  },
+  {
+    name: "client_create",
+    description: "Create a new client",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Client name" },
+        industry: { type: "string", description: "Industry" },
+        website: { type: "string", description: "Website URL" },
+        description: { type: "string", description: "Description" },
+        primaryContactName: { type: "string", description: "Primary contact name" },
+        primaryContactEmail: { type: "string", description: "Primary contact email" },
+        primaryContactPhone: { type: "string", description: "Primary contact phone" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "client_update",
+    description: "Update an existing client",
+    inputSchema: {
+      type: "object",
+      properties: {
+        clientId: { type: "string", description: "Client ID" },
+        name: { type: "string", description: "New name" },
+        industry: { type: "string", description: "New industry" },
+        website: { type: "string", description: "New website" },
+        description: { type: "string", description: "New description" },
+        healthScore: { type: "number", description: "Health score (1-100)" },
+        primaryContactName: { type: "string", description: "Primary contact name" },
+        primaryContactEmail: { type: "string", description: "Primary contact email" },
+        primaryContactPhone: { type: "string", description: "Primary contact phone" }
+      },
+      required: ["clientId"]
+    }
+  }
+];
+async function handleClientSearch(args) {
+  const input = ClientSearchSchema.parse(args);
+  const result = await apiGet("/clients", {
+    query: input.query,
+    industry: input.industry,
+    limit: input.limit ?? 20
+  });
+  return { count: result.count, clients: result.clients };
+}
+async function handleClientCreate(args) {
+  const input = ClientCreateSchema.parse(args);
+  const client = await apiPost("/clients", input);
+  return { id: client.id, name: client.name, industry: client.industry };
+}
+async function handleClientUpdate(args) {
+  const input = ClientUpdateSchema.parse(args);
+  const { clientId, ...data } = input;
+  const updated = await apiPatch(`/clients/${clientId}`, data);
+  return { id: updated.id, name: updated.name, industry: updated.industry, healthScore: updated.healthScore };
+}
+async function handleToolCall7(name, args) {
+  try {
+    switch (name) {
+      case "client_search":
+        return success(await handleClientSearch(args));
+      case "client_create":
+        return success(await handleClientCreate(args));
+      case "client_update":
+        return success(await handleClientUpdate(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/people-tools.ts
+var people_tools_exports = {};
+__export(people_tools_exports, {
+  handleToolCall: () => handleToolCall8,
+  tools: () => tools8
+});
+import { z as z9 } from "zod";
+var PersonSearchSchema = z9.object({
+  query: z9.string().optional(),
+  role: z9.string().optional(),
+  skill: z9.string().optional(),
+  available: z9.boolean().optional(),
+  limit: z9.number().optional()
+});
+var tools8 = [
+  {
+    name: "person_search",
+    description: "Search people by name, role, skill, or availability",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search person names" },
+        role: { type: "string", description: "Filter by role/title" },
+        skill: { type: "string", description: "Filter by capability name" },
+        available: { type: "boolean", description: "Only show people with available capacity" },
+        limit: { type: "number", description: "Max results (default 20)" }
+      }
+    }
+  }
+];
+async function handlePersonSearch(args) {
+  const input = PersonSearchSchema.parse(args);
+  const result = await apiGet("/people", {
+    query: input.query,
+    role: input.role,
+    skill: input.skill,
+    available: input.available,
+    limit: input.limit ?? 20
+  });
+  return { count: result.count, people: result.people };
+}
+async function handleToolCall8(name, args) {
+  try {
+    switch (name) {
+      case "person_search":
+        return success(await handlePersonSearch(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/document-tools.ts
+var document_tools_exports = {};
+__export(document_tools_exports, {
+  handleToolCall: () => handleToolCall9,
+  tools: () => tools9
+});
+import { z as z10 } from "zod";
+var DocumentSearchSchema = z10.object({ query: z10.string().optional(), type: z10.string().optional(), projectId: z10.string().optional(), personId: z10.string().optional(), limit: z10.number().optional() });
+var DocumentCreateSchema = z10.object({ name: z10.string(), type: caseInsensitiveEnum(["RESUME", "PROPOSAL", "REPORT", "CAPABILITY_STATEMENT", "LETTER", "OTHER"]), personId: z10.string().optional(), projectId: z10.string().optional(), notes: z10.string().optional() });
+var tools9 = [
+  { name: "document_search", description: "Search documents", inputSchema: { type: "object", properties: { query: { type: "string" }, type: { type: "string" }, projectId: { type: "string" }, personId: { type: "string" }, limit: { type: "number" } } } },
+  { name: "document_create", description: "Create a new document", inputSchema: { type: "object", properties: { name: { type: "string" }, type: { type: "string" }, personId: { type: "string" }, projectId: { type: "string" }, notes: { type: "string" } }, required: ["name", "type"] } }
+];
+async function handleDocumentSearch(args) {
+  const input = DocumentSearchSchema.parse(args);
+  const result = await apiGet("/documents", input);
+  return { count: result.count, documents: result.documents };
+}
+async function handleDocumentCreate(args) {
+  const input = DocumentCreateSchema.parse(args);
+  const doc = await apiPost("/documents", input);
+  return { id: doc.id, name: doc.title, type: doc.type, status: doc.status };
+}
+async function handleToolCall9(name, args) {
+  try {
+    switch (name) {
+      case "document_search":
+        return success(await handleDocumentSearch(args));
+      case "document_create":
+        return success(await handleDocumentCreate(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/knowledge-tools.ts
+var knowledge_tools_exports = {};
+__export(knowledge_tools_exports, {
+  handleToolCall: () => handleToolCall10,
+  tools: () => tools10
+});
+import { z as z11 } from "zod";
+var KBSearchSchema = z11.object({ query: z11.string().max(1e3), projectId: z11.string().optional(), limit: z11.number().optional() });
+var tools10 = [
+  { name: "kb_search", description: "Search the knowledge base using semantic search", inputSchema: { type: "object", properties: { query: { type: "string" }, projectId: { type: "string" }, limit: { type: "number" } }, required: ["query"] } }
+];
+async function handleKBSearch2(args) {
+  const input = KBSearchSchema.parse(args);
+  return await apiGet("/knowledge/search", input);
+}
+async function handleToolCall10(name, args) {
+  try {
+    switch (name) {
+      case "kb_search":
+        return success(await handleKBSearch2(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/project-tools.ts
+var project_tools_exports = {};
+__export(project_tools_exports, {
+  handleToolCall: () => handleToolCall11,
+  tools: () => tools11
+});
+import { z as z12 } from "zod";
+var ProjectSearchSchema = z12.object({
+  query: z12.string().optional(),
+  status: z12.string().optional(),
+  clientId: z12.string().optional(),
+  lifecycleStage: z12.string().optional(),
+  limit: z12.number().optional()
+});
+var tools11 = [
+  {
+    name: "project_search",
+    description: "Search projects by name, status, client, or lifecycle stage",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search project names" },
+        status: { type: "string", enum: ["SCOPING", "ACTIVE", "ON_HOLD", "COMPLETED", "ARCHIVED"], description: "Filter by status" },
+        clientId: { type: "string", description: "Filter by client ID" },
+        lifecycleStage: { type: "string", description: "Filter by lifecycle stage" },
+        limit: { type: "number", description: "Max results (default 20)" }
+      }
+    }
+  }
+];
+async function handleProjectSearch(args) {
+  const input = ProjectSearchSchema.parse(args);
+  const result = await apiGet("/projects", {
+    query: input.query,
+    status: input.status,
+    clientId: input.clientId,
+    lifecycleStage: input.lifecycleStage,
+    limit: input.limit ?? 20
+  });
+  return { count: result.count, projects: result.projects };
+}
+async function handleToolCall11(name, args) {
+  try {
+    switch (name) {
+      case "project_search":
+        return success(await handleProjectSearch(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/credential-tools.ts
+var credential_tools_exports = {};
+__export(credential_tools_exports, {
+  handleToolCall: () => handleToolCall12,
+  tools: () => tools12
+});
+import { z as z13 } from "zod";
+var credentialTypeValues = ["CERTIFICATION", "LICENSE", "CLEARANCE", "MEDICAL", "TRAINING", "TICKET", "MEMBERSHIP", "INSURANCE", "IDENTITY", "OTHER"];
+var credentialStatusValues = ["PENDING_UPLOAD", "PENDING_VERIFICATION", "VERIFIED", "EXPIRED", "EXPIRING_SOON", "REJECTED", "SUSPENDED"];
+var CredentialCreateSchema = z13.object({
+  personId: z13.string(),
+  type: caseInsensitiveEnum(credentialTypeValues),
+  name: z13.string(),
+  issuer: z13.string().optional(),
+  credentialNumber: z13.string().optional(),
+  category: z13.string().optional(),
+  issuedAt: z13.string().optional(),
+  expiresAt: z13.string().optional(),
+  notes: z13.string().optional()
+});
+var CredentialUpdateSchema = z13.object({
+  credentialId: z13.string(),
+  status: caseInsensitiveEnumOptional(credentialStatusValues),
+  expiresAt: z13.string().optional(),
+  notes: z13.string().optional()
+});
+var CredentialSearchSchema = z13.object({
+  personId: z13.string().optional(),
+  type: z13.string().optional(),
+  status: z13.string().optional(),
+  expiringWithinDays: z13.number().optional(),
+  query: z13.string().optional(),
+  limit: z13.number().optional()
+});
+var tools12 = [
+  { name: "credential_create", description: "Create a new credential for a person", inputSchema: { type: "object", properties: { personId: { type: "string" }, type: { type: "string" }, name: { type: "string" }, issuer: { type: "string" }, credentialNumber: { type: "string" }, category: { type: "string" }, issuedAt: { type: "string" }, expiresAt: { type: "string" }, notes: { type: "string" } }, required: ["personId", "type", "name"] } },
+  { name: "credential_update", description: "Update an existing credential", inputSchema: { type: "object", properties: { credentialId: { type: "string" }, status: { type: "string" }, expiresAt: { type: "string" }, notes: { type: "string" } }, required: ["credentialId"] } },
+  { name: "credential_search", description: "Search credentials", inputSchema: { type: "object", properties: { personId: { type: "string" }, type: { type: "string" }, status: { type: "string" }, expiringWithinDays: { type: "number" }, query: { type: "string" }, limit: { type: "number" } } } }
+];
+async function handleCredentialCreate(args) {
+  const input = CredentialCreateSchema.parse(args);
+  const cred = await apiPost("/credentials", input);
+  return { id: cred.id, name: cred.name, type: cred.type, status: cred.status };
+}
+async function handleCredentialUpdate(args) {
+  const input = CredentialUpdateSchema.parse(args);
+  const updated = await apiPatch(`/credentials/${input.credentialId}`, input);
+  return { id: updated.id, name: updated.name, status: updated.status, expiresAt: updated.expiresAt };
+}
+async function handleCredentialSearch(args) {
+  const input = CredentialSearchSchema.parse(args);
+  const result = await apiGet("/credentials", input);
+  return { count: result.count, credentials: result.credentials };
+}
+async function handleToolCall12(name, args) {
+  try {
+    switch (name) {
+      case "credential_create":
+        return success(await handleCredentialCreate(args));
+      case "credential_update":
+        return success(await handleCredentialUpdate(args));
+      case "credential_search":
+        return success(await handleCredentialSearch(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/capability-tools.ts
+var capability_tools_exports = {};
+__export(capability_tools_exports, {
+  handleToolCall: () => handleToolCall13,
+  tools: () => tools13
+});
+import { z as z14 } from "zod";
+var CapabilityAddSchema = z14.object({
+  personId: z14.string(),
+  category: caseInsensitiveEnum(["DOMAIN", "INDUSTRY", "TOOL", "METHODOLOGY", "SOFT_SKILL"]),
+  name: z14.string(),
+  proficiency: caseInsensitiveEnum(["NOVICE", "COMPETENT", "PROFICIENT", "EXPERT"]),
+  yearsExperience: z14.number().optional()
+});
+var CapabilityUpdateSchema = z14.object({
+  capabilityId: z14.string(),
+  proficiency: caseInsensitiveEnumOptional(["NOVICE", "COMPETENT", "PROFICIENT", "EXPERT"]),
+  yearsExperience: z14.number().optional()
+});
+var CapabilityEvidenceAddSchema = z14.object({
+  capabilityId: z14.string(),
+  type: caseInsensitiveEnum(["PROJECT_DELIVERABLE", "PRESENTATION", "PUBLICATION", "REFERENCE", "METRIC", "CERTIFICATION"]),
+  title: z14.string(),
+  description: z14.string().optional(),
+  projectId: z14.string().optional(),
+  documentId: z14.string().optional()
+});
+var tools13 = [
+  { name: "capability_add", description: "Add a capability/skill to a person", inputSchema: { type: "object", properties: { personId: { type: "string" }, category: { type: "string", enum: ["DOMAIN", "INDUSTRY", "TOOL", "METHODOLOGY", "SOFT_SKILL"] }, name: { type: "string" }, proficiency: { type: "string", enum: ["NOVICE", "COMPETENT", "PROFICIENT", "EXPERT"] }, yearsExperience: { type: "number" } }, required: ["personId", "category", "name", "proficiency"] } },
+  { name: "capability_update", description: "Update an existing capability", inputSchema: { type: "object", properties: { capabilityId: { type: "string" }, proficiency: { type: "string" }, yearsExperience: { type: "number" } }, required: ["capabilityId"] } },
+  { name: "capability_evidence_add", description: "Add evidence supporting a capability", inputSchema: { type: "object", properties: { capabilityId: { type: "string" }, type: { type: "string" }, title: { type: "string" }, description: { type: "string" }, projectId: { type: "string" }, documentId: { type: "string" } }, required: ["capabilityId", "type", "title"] } }
+];
+async function handleCapabilityAdd(args) {
+  const input = CapabilityAddSchema.parse(args);
+  const cap = await apiPost("/capabilities", input);
+  return { id: cap.id, name: cap.name, category: cap.category, proficiency: cap.proficiency };
+}
+async function handleCapabilityUpdate(args) {
+  const input = CapabilityUpdateSchema.parse(args);
+  const updated = await apiPatch(`/capabilities/${input.capabilityId}`, input);
+  return { id: updated.id, name: updated.name, proficiency: updated.proficiency };
+}
+async function handleCapabilityEvidenceAdd(args) {
+  const input = CapabilityEvidenceAddSchema.parse(args);
+  const evidence = await apiPost(`/capabilities/${input.capabilityId}/evidence`, input);
+  return evidence;
+}
+async function handleToolCall13(name, args) {
+  try {
+    switch (name) {
+      case "capability_add":
+        return success(await handleCapabilityAdd(args));
+      case "capability_update":
+        return success(await handleCapabilityUpdate(args));
+      case "capability_evidence_add":
+        return success(await handleCapabilityEvidenceAdd(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/availability-tools.ts
+var availability_tools_exports = {};
+__export(availability_tools_exports, {
+  handleToolCall: () => handleToolCall14,
+  tools: () => tools14
+});
+import { z as z15 } from "zod";
+var availabilityStatusValues = ["AVAILABLE", "UNAVAILABLE", "LEAVE", "PUBLIC_HOLIDAY", "PARTIALLY_AVAILABLE"];
+var AvailabilitySetSchema = z15.object({
+  personId: z15.string(),
+  date: z15.string(),
+  status: caseInsensitiveEnum(availabilityStatusValues),
+  hours: z15.number().optional(),
+  note: z15.string().optional()
+});
+var AvailabilityBulkSetSchema = z15.object({
+  personId: z15.string(),
+  entries: z15.array(z15.object({
+    date: z15.string(),
+    status: caseInsensitiveEnum(availabilityStatusValues),
+    hours: z15.number().optional(),
+    note: z15.string().optional()
+  })).max(366)
+});
+var AvailabilityQuerySchema = z15.object({
+  personId: z15.string().optional(),
+  startDate: z15.string(),
+  endDate: z15.string(),
+  status: caseInsensitiveEnumOptional(availabilityStatusValues)
+});
+var tools14 = [
+  { name: "availability_set", description: "Set availability for a person on a specific date", inputSchema: { type: "object", properties: { personId: { type: "string" }, date: { type: "string" }, status: { type: "string", enum: ["AVAILABLE", "UNAVAILABLE", "LEAVE", "PUBLIC_HOLIDAY", "PARTIALLY_AVAILABLE"] }, hours: { type: "number" }, note: { type: "string" } }, required: ["personId", "date", "status"] } },
+  { name: "availability_bulk_set", description: "Set availability for multiple dates at once", inputSchema: { type: "object", properties: { personId: { type: "string" }, entries: { type: "array", items: { type: "object" } } }, required: ["personId", "entries"] } },
+  { name: "availability_query", description: "Query availability for a person or team", inputSchema: { type: "object", properties: { personId: { type: "string" }, startDate: { type: "string" }, endDate: { type: "string" }, status: { type: "string" } }, required: ["startDate", "endDate"] } }
+];
+async function handleAvailabilitySet(args) {
+  const input = AvailabilitySetSchema.parse(args);
+  const day = await apiPost("/availability", input);
+  return { id: day.id, date: day.date, status: day.status, hours: day.availableHours };
+}
+async function handleAvailabilityBulkSet(args) {
+  const input = AvailabilityBulkSetSchema.parse(args);
+  return await apiPost("/availability/bulk", input);
+}
+async function handleAvailabilityQuery(args) {
+  const input = AvailabilityQuerySchema.parse(args);
+  const result = await apiGet("/availability", input);
+  return { count: result.count, days: result.days };
+}
+async function handleToolCall14(name, args) {
+  try {
+    switch (name) {
+      case "availability_set":
+        return success(await handleAvailabilitySet(args));
+      case "availability_bulk_set":
+        return success(await handleAvailabilityBulkSet(args));
+      case "availability_query":
+        return success(await handleAvailabilityQuery(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/contact-tools.ts
+var contact_tools_exports = {};
+__export(contact_tools_exports, {
+  handleToolCall: () => handleToolCall15,
+  tools: () => tools15
+});
+import { z as z16 } from "zod";
+var ContactCreateSchema = z16.object({
+  firstName: z16.string(),
+  lastName: z16.string(),
+  email: z16.string().optional(),
+  phone: z16.string().optional(),
+  title: z16.string().optional(),
+  department: z16.string().optional(),
+  role: caseInsensitiveEnumOptional(["CHAMPION", "DECISION_MAKER", "INFLUENCER", "USER", "BLOCKER"]),
+  clientId: z16.string().optional(),
+  notes: z16.string().optional(),
+  linkedInUrl: z16.string().optional()
+});
+var tools15 = [
+  {
+    name: "contact_create",
+    description: "Create a new global contact",
+    inputSchema: {
+      type: "object",
+      properties: {
+        firstName: { type: "string", description: "First name" },
+        lastName: { type: "string", description: "Last name" },
+        email: { type: "string", description: "Email" },
+        phone: { type: "string", description: "Phone number" },
+        title: { type: "string", description: "Job title" },
+        department: { type: "string", description: "Department" },
+        role: { type: "string", enum: ["CHAMPION", "DECISION_MAKER", "INFLUENCER", "USER", "BLOCKER"], description: "Contact role" },
+        clientId: { type: "string", description: "Associated client ID" },
+        notes: { type: "string", description: "Notes" },
+        linkedInUrl: { type: "string", description: "LinkedIn URL" }
+      },
+      required: ["firstName"]
+    }
+  }
+];
+async function handleContactCreate(args) {
+  const input = ContactCreateSchema.parse(args);
+  const contact = await apiPost("/contacts", input);
+  return { id: contact.id, name: `${contact.firstName ?? ""} ${contact.lastName ?? ""}`.trim(), email: contact.email, role: contact.role };
+}
+async function handleToolCall15(name, args) {
+  try {
+    switch (name) {
+      case "contact_create":
+        return success(await handleContactCreate(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/deliverable-tools.ts
+var deliverable_tools_exports = {};
+__export(deliverable_tools_exports, {
+  handleToolCall: () => handleToolCall16,
+  tools: () => tools16
+});
+import { z as z17 } from "zod";
+var DeliverableCreateSchema = z17.object({
+  projectId: z17.string(),
+  name: z17.string(),
+  description: z17.string().optional(),
+  type: caseInsensitiveEnumOptional(["REPORT", "MODEL", "WORKSHOP", "DASHBOARD", "OTHER"]),
+  billingModel: caseInsensitiveEnumOptional(["FIXED_FEE", "TIME_AND_MATERIALS", "MILESTONE", "UNIT_PRICE"]),
+  priceTotal: z17.number().optional(),
+  budgetHours: z17.number().optional()
+});
+var DeliverableUpdateSchema = z17.object({
+  deliverableId: z17.string(),
+  status: caseInsensitiveEnumOptional(["NOT_STARTED", "IN_PROGRESS", "UNDER_REVIEW", "COMPLETED"]),
+  percentComplete: z17.number().optional(),
+  name: z17.string().optional(),
+  description: z17.string().optional()
+});
+var tools16 = [
+  { name: "deliverable_create", description: "Create a new deliverable in a project", inputSchema: { type: "object", properties: { projectId: { type: "string" }, name: { type: "string" }, description: { type: "string" }, type: { type: "string" }, billingModel: { type: "string" }, priceTotal: { type: "number" }, budgetHours: { type: "number" } }, required: ["projectId", "name"] } },
+  { name: "deliverable_update", description: "Update an existing deliverable", inputSchema: { type: "object", properties: { deliverableId: { type: "string" }, status: { type: "string" }, percentComplete: { type: "number" }, name: { type: "string" }, description: { type: "string" } }, required: ["deliverableId"] } }
+];
+async function handleDeliverableCreate(args) {
+  const input = DeliverableCreateSchema.parse(args);
+  const d = await apiPost("/deliverables", input);
+  return { id: d.id, name: d.name, type: d.type, status: d.status };
+}
+async function handleDeliverableUpdate(args) {
+  const input = DeliverableUpdateSchema.parse(args);
+  const updated = await apiPatch(`/deliverables/${input.deliverableId}`, input);
+  return { id: updated.id, name: updated.name, status: updated.status, percentComplete: updated.percentComplete };
+}
+async function handleToolCall16(name, args) {
+  try {
+    switch (name) {
+      case "deliverable_create":
+        return success(await handleDeliverableCreate(args));
+      case "deliverable_update":
+        return success(await handleDeliverableUpdate(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/memory-tools.ts
+var memory_tools_exports = {};
+__export(memory_tools_exports, {
+  handleToolCall: () => handleToolCall17,
+  tools: () => tools17
+});
+import { z as z18 } from "zod";
+var entityTypeValues = ["project", "client", "person", "org"];
+var memoryCategoryValues = ["preference", "decision", "risk", "relationship", "process", "context", "lesson_learned"];
+var MemoryStoreSchema = z18.object({ entityType: caseInsensitiveEnum(entityTypeValues), entityId: z18.string().optional(), category: caseInsensitiveEnum(memoryCategoryValues), content: z18.string().max(1e4), source: z18.string().optional() });
+var MemoryRecallSchema = z18.object({ entityType: caseInsensitiveEnum(entityTypeValues), entityId: z18.string(), limit: z18.number().optional() });
+var MemorySearchSchema = z18.object({ query: z18.string().max(1e3), entityType: caseInsensitiveEnumOptional(entityTypeValues), limit: z18.number().optional() });
+var DecisionLogSchema = z18.object({ projectId: z18.string().optional(), title: z18.string(), decision: z18.string(), rationale: z18.string(), alternatives: z18.string().optional(), decidedBy: z18.string().optional() });
+var MeetingSummarizeSchema = z18.object({ projectId: z18.string().optional(), clientId: z18.string().optional(), title: z18.string(), date: z18.string(), attendees: z18.array(z18.string()).max(100), rawNotes: z18.string().max(5e4) });
+var tools17 = [
+  { name: "memory_store", description: "Store a memory about an entity", inputSchema: { type: "object", properties: { entityType: { type: "string" }, entityId: { type: "string" }, category: { type: "string" }, content: { type: "string" }, source: { type: "string" } }, required: ["entityType", "category", "content"] } },
+  { name: "memory_recall", description: "Recall memories about an entity", inputSchema: { type: "object", properties: { entityType: { type: "string" }, entityId: { type: "string" }, limit: { type: "number" } }, required: ["entityType", "entityId"] } },
+  { name: "memory_search", description: "Search memories semantically", inputSchema: { type: "object", properties: { query: { type: "string" }, entityType: { type: "string" }, limit: { type: "number" } }, required: ["query"] } },
+  { name: "decision_log", description: "Log a decision with rationale", inputSchema: { type: "object", properties: { projectId: { type: "string" }, title: { type: "string" }, decision: { type: "string" }, rationale: { type: "string" }, alternatives: { type: "string" }, decidedBy: { type: "string" } }, required: ["title", "decision", "rationale"] } },
+  { name: "meeting_summarize", description: "Create a meeting note with auto-extracted items", inputSchema: { type: "object", properties: { projectId: { type: "string" }, clientId: { type: "string" }, title: { type: "string" }, date: { type: "string" }, attendees: { type: "array" }, rawNotes: { type: "string" } }, required: ["title", "date", "attendees", "rawNotes"] } }
+];
+async function handleMemoryStore(args) {
+  const input = MemoryStoreSchema.parse(args);
+  return await apiPost("/memory", input);
+}
+async function handleMemoryRecall(args) {
+  const input = MemoryRecallSchema.parse(args);
+  return await apiGet("/memory/recall", input);
+}
+async function handleMemorySearch2(args) {
+  const input = MemorySearchSchema.parse(args);
+  return await apiGet("/memory/search", input);
+}
+async function handleDecisionLog(args) {
+  const input = DecisionLogSchema.parse(args);
+  return await apiPost("/memory/decisions", input);
+}
+async function handleMeetingSummarize(args) {
+  const input = MeetingSummarizeSchema.parse(args);
+  return await apiPost("/memory/meetings", input);
+}
+async function handleToolCall17(name, args) {
+  try {
+    switch (name) {
+      case "memory_store":
+        return success(await handleMemoryStore(args));
+      case "memory_recall":
+        return success(await handleMemoryRecall(args));
+      case "memory_search":
+        return success(await handleMemorySearch2(args));
+      case "decision_log":
+        return success(await handleDecisionLog(args));
+      case "meeting_summarize":
+        return success(await handleMeetingSummarize(args));
+      default:
+        return null;
+    }
+  } catch (err) {
+    console.error(`Tool ${name} failed:`, err instanceof Error ? err.message : err);
+    return safeError(err);
+  }
+}
+
+// src/tools/index.ts
+var modules2 = [
+  task_tools_exports,
+  time_tools_exports,
+  note_tools_exports,
+  pipeline_tools_exports,
+  alert_tools_exports,
+  compliance_tools_exports,
+  client_tools_exports,
+  people_tools_exports,
+  document_tools_exports,
+  knowledge_tools_exports,
+  project_tools_exports,
+  credential_tools_exports,
+  capability_tools_exports,
+  availability_tools_exports,
+  contact_tools_exports,
+  deliverable_tools_exports,
+  memory_tools_exports
+];
+var tools18 = modules2.flatMap((m) => [...m.tools]);
+async function handleToolCall18(name, args) {
+  try {
+    checkRateLimit(name);
+  } catch (err) {
+    if (err instanceof RateLimitError) {
+      return error(err.message);
+    }
+    return error(sanitizeError(err));
+  }
+  const a = args ?? {};
+  for (const mod of modules2) {
+    const result = await mod.handleToolCall(name, a);
+    if (result) return result;
+  }
+  return error(`Unknown tool: ${name}`);
+}
+
+// src/prompts/weekly-status.ts
+var weekly_status_exports = {};
+__export(weekly_status_exports, {
+  generate: () => generate
+});
+
+// src/prompts/_data-fetchers.ts
+async function fetchProjectWithDetails(projectId) {
+  const result = await apiGet(`/prompts/project/${projectId}/details`);
+  return result;
+}
+async function fetchTimeEntries(filters) {
+  const result = await apiGet("/prompts/time-entries", {
+    projectId: filters.projectId,
+    personId: filters.personId,
+    fromDate: filters.fromDate?.toISOString(),
+    toDate: filters.toDate?.toISOString()
+  });
+  return result;
+}
+async function fetchPersonTasks(personId, options) {
+  const result = await apiGet(`/prompts/people/${personId}/tasks`, {
+    status: options?.status?.join(","),
+    fromDate: options?.fromDate?.toISOString(),
+    toDate: options?.toDate?.toISOString()
+  });
+  return result.tasks;
+}
+async function fetchClientActivity(clientId, days = 14) {
+  const result = await apiGet(`/prompts/clients/${clientId}/activity`, { days });
+  return result;
+}
+async function fetchExpiringCredentials(withinDays = 30) {
+  const result = await apiGet("/prompts/credentials/expiring", { days: withinDays });
+  return result.credentials;
+}
+async function fetchTeamAvailability(startDate, endDate) {
+  const result = await apiGet("/prompts/team/availability", {
+    startDate: startDate.toISOString(),
+    endDate: endDate.toISOString()
+  });
+  return result;
+}
+async function fetchPipelineData(stageFilter) {
+  const result = await apiGet("/prompts/pipeline", {
+    stage: stageFilter
+  });
+  return result;
+}
+async function fetchRiskMemories(projectId) {
+  const result = await apiGet("/prompts/memories/risks", {
+    projectId
+  });
+  return result.memories;
+}
+async function fetchPersonByUserId(userId) {
+  const result = await apiGet(`/prompts/people/by-user/${userId}`);
+  return result.person;
+}
+async function fetchUnbilledTime(clientId, options) {
+  const result = await apiGet(`/prompts/clients/${clientId}/unbilled-time`, {
+    projectId: options?.projectId,
+    fromDate: options?.fromDate?.toISOString(),
+    toDate: options?.toDate?.toISOString()
+  });
+  return result;
+}
+async function fetchProjectDecisions(projectId) {
+  const result = await apiGet(`/prompts/projects/${projectId}/decisions`);
+  return result.decisions;
+}
+
+// src/prompts/weekly-status.ts
+async function generate(args) {
+  const data = await fetchProjectWithDetails(args.projectId);
+  if (!data) return `Project ${args.projectId} not found.`;
+  const { project, alerts, taskStats, allTasks } = data;
+  const now = /* @__PURE__ */ new Date();
+  const weekStart = new Date(now);
+  weekStart.setDate(now.getDate() - now.getDay() + 1);
+  weekStart.setHours(0, 0, 0, 0);
+  const weekEnd = new Date(weekStart);
+  weekEnd.setDate(weekStart.getDate() + 6);
+  const timeData = await fetchTimeEntries({
+    projectId: args.projectId,
+    fromDate: weekStart,
+    toDate: weekEnd
+  });
+  const tasks = allTasks || [];
+  const completedTasks = tasks.filter((t) => t.status === "COMPLETED");
+  const inProgressTasks = tasks.filter((t) => t.status === "IN_PROGRESS");
+  const blockedTasks = tasks.filter((t) => t.status === "BLOCKED");
+  const overdueTasks = tasks.filter((t) => t.endDate && new Date(t.endDate) < now && t.status !== "COMPLETED");
+  const completedList = completedTasks.length > 0 ? completedTasks.map((t) => `- ${t.name}`).join("\n") : "- None this period";
+  const inProgressList = inProgressTasks.length > 0 ? inProgressTasks.map((t) => {
+    const dueStr = t.endDate ? ` (due ${typeof t.endDate === "string" ? t.endDate.split("T")[0] : ""})` : "";
+    return `- ${t.name}${dueStr}`;
+  }).join("\n") : "- None";
+  const blockedList = blockedTasks.length > 0 ? blockedTasks.map((t) => `- ${t.name}`).join("\n") : "- None";
+  const overdueList = overdueTasks.length > 0 ? overdueTasks.map((t) => `- ${t.name} (due ${typeof t.endDate === "string" ? t.endDate.split("T")[0] : ""})`).join("\n") : "- None";
+  const alertList = alerts || [];
+  const alertsList = alertList.length > 0 ? alertList.map((a) => `- [${a.priority}] ${a.title} (${a.status})`).join("\n") : "- No active alerts";
+  const deliverables = project.deliverables || [];
+  const deliverableList = deliverables.map((d) => {
+    const dAny = d;
+    const pct = Number(dAny.percentComplete ?? 0);
+    const tasksArr = dAny.tasks;
+    const taskCount = tasksArr ? tasksArr.length : dAny.taskCount ?? 0;
+    return `- ${d.name}: ${d.status} (${pct}% complete, ${taskCount} tasks)`;
+  }).join("\n");
+  const stats = taskStats || { total: 0, completed: 0, inProgress: 0, blocked: 0, overdue: 0 };
+  const allocations = project.allocations || [];
+  return `# Weekly Status Report
+Project: ${project.name}
+Client: ${project.client?.name || "N/A"}
+Week of: ${weekStart.toISOString().split("T")[0]}
+
+## Task Summary
+| Metric | Count |
+|--------|-------|
+| Total tasks | ${stats.total} |
+| Completed | ${stats.completed} |
+| In Progress | ${stats.inProgress} |
+| Blocked | ${stats.blocked} |
+| Overdue | ${stats.overdue} |
+
+## Completed This Week
+${completedList}
+
+## In Progress
+${inProgressList}
+
+## Blocked
+${blockedList}
+
+## Overdue
+${overdueList}
+
+## Deliverables
+${deliverableList}
+
+## Time Logged This Week
+- Total hours: ${timeData.totalHours.toFixed(1)}h
+- Billable hours: ${timeData.billableHours.toFixed(1)}h
+- Entries: ${timeData.entries.length}
+
+## Active Alerts & Risks
+${alertsList}
+
+## Team Allocation
+${allocations.map((a) => `- ${a.person?.name || "Unknown"}: ${Number(a.hoursPerWeek || 0)}h/week`).join("\n") || "- No allocations recorded"}
+
+Based on the data above, please generate:
+1. An executive summary (2-3 sentences)
+2. Key risks and recommended mitigations
+3. Planned focus for next week`;
+}
+
+// src/prompts/daily-standup.ts
+var daily_standup_exports = {};
+__export(daily_standup_exports, {
+  generate: () => generate2
+});
+async function generate2(args) {
+  const person = await fetchPersonByUserId(args.userId);
+  if (!person) return `No person record found for user ${args.userId}.`;
+  const today = args.date ? new Date(args.date) : /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  const yesterday = new Date(today);
+  yesterday.setDate(today.getDate() - (today.getDay() === 1 ? 3 : 1));
+  const tomorrow = new Date(today);
+  tomorrow.setDate(today.getDate() + 1);
+  const weekStart = new Date(today);
+  weekStart.setDate(today.getDate() - today.getDay() + 1);
+  weekStart.setHours(0, 0, 0, 0);
+  const weekEnd = new Date(weekStart);
+  weekEnd.setDate(weekStart.getDate() + 6);
+  const yesterdayTime = await fetchTimeEntries({
+    personId: person.id,
+    fromDate: yesterday,
+    toDate: yesterday,
+    ...args.projectId && { projectId: args.projectId }
+  });
+  const weekTime = await fetchTimeEntries({
+    personId: person.id,
+    fromDate: weekStart,
+    toDate: weekEnd,
+    ...args.projectId && { projectId: args.projectId }
+  });
+  const inProgressTasks = await fetchPersonTasks(person.id, {
+    status: ["IN_PROGRESS"]
+  });
+  const blockedTasks = await fetchPersonTasks(person.id, {
+    status: ["BLOCKED"]
+  });
+  const allAssigned = await fetchPersonTasks(person.id, {
+    status: ["NOT_STARTED", "IN_PROGRESS"]
+  });
+  const overdueTasks = allAssigned.filter((t) => t.endDate && new Date(t.endDate) < today);
+  const yesterdayEntries = yesterdayTime.entries.length > 0 ? yesterdayTime.entries.map((e) => {
+    const projName = e.project?.name || "Unknown";
+    const taskName = e.task?.name || "";
+    return `- ${projName}${taskName ? ` / ${taskName}` : ""}: ${e.description || "No description"} (${Number(e.hours)}h)`;
+  }).join("\n") : "- No time logged yesterday";
+  const todayTasks = inProgressTasks.length > 0 ? inProgressTasks.map((t) => {
+    const due = t.endDate ? ` \u2014 due ${typeof t.endDate === "string" ? t.endDate.split("T")[0] : ""}` : "";
+    return `- ${t.project?.name || "Unknown"} / ${t.name}${due}`;
+  }).join("\n") : "- No tasks currently in progress";
+  const blockersList = blockedTasks.length > 0 ? blockedTasks.map((t) => `- ${t.project?.name || "Unknown"} / ${t.name}`).join("\n") : "- No blockers";
+  const overdueList = overdueTasks.length > 0 ? overdueTasks.map((t) => `- ${t.project?.name || "Unknown"} / ${t.name} (due ${typeof t.endDate === "string" ? t.endDate.split("T")[0] : ""})`).join("\n") : "";
+  return `# Daily Standup
+Person: ${person.name}
+Date: ${today.toISOString().split("T")[0]}
+${args.projectId ? `Project filter: ${args.projectId}` : ""}
+
+## What I completed yesterday
+${yesterdayEntries}
+- Total: ${yesterdayTime.totalHours.toFixed(1)}h
+
+## What I'm working on today
+${todayTasks}
+
+## Blockers & Risks
+${blockersList}
+${overdueList ? `
+### Overdue Tasks
+${overdueList}` : ""}
+
+## Hours Summary
+- Yesterday: ${yesterdayTime.totalHours.toFixed(1)}h
+- This week so far: ${weekTime.totalHours.toFixed(1)}h (billable: ${weekTime.billableHours.toFixed(1)}h)
+
+Based on this data, please summarize for standup in 2-3 concise bullet points per section.`;
+}
+
+// src/prompts/project-health.ts
+var project_health_exports = {};
+__export(project_health_exports, {
+  generate: () => generate3
+});
+async function generate3(args) {
+  const data = await fetchProjectWithDetails(args.projectId);
+  if (!data) return `Project ${args.projectId} not found.`;
+  const { project, alerts, taskStats } = data;
+  const now = /* @__PURE__ */ new Date();
+  const timeData = await fetchTimeEntries({ projectId: args.projectId });
+  const deliverables = project.deliverables || [];
+  const totalBudget = deliverables.reduce((sum, d) => sum + Number(d.priceTotal || 0), 0);
+  const totalBudgetHours = deliverables.reduce((sum, d) => sum + Number(d.budgetHours || 0), 0);
+  const hoursUsed = timeData.totalHours;
+  const budgetBurnPct = totalBudgetHours > 0 ? (hoursUsed / totalBudgetHours * 100).toFixed(1) : "N/A";
+  const startDateStr = project.startDate;
+  const endDateStr = project.endDate;
+  const startDate = startDateStr ? new Date(startDateStr) : null;
+  const endDate = endDateStr ? new Date(endDateStr) : null;
+  let timelineElapsedPct = "N/A";
+  if (startDate && endDate) {
+    const total = endDate.getTime() - startDate.getTime();
+    const elapsed = now.getTime() - startDate.getTime();
+    timelineElapsedPct = total > 0 ? (elapsed / total * 100).toFixed(1) : "0";
+  }
+  const allocations = project.allocations || [];
+  const teamMembers = allocations.map((a) => ({
+    name: a.person?.name || "Unknown",
+    hoursPerWeek: Number(a.hoursPerWeek || 0)
+  }));
+  const deliverableDetails = deliverables.map((d) => {
+    const pct = Number(d.percentComplete ?? 0);
+    const dAny = d;
+    const tasksArr = dAny.tasks;
+    const taskInfo = tasksArr ? `${tasksArr.filter((t) => t.status === "COMPLETED").length}/${tasksArr.length} tasks` : `${dAny.taskCount ?? 0} tasks`;
+    return `| ${d.name} | ${d.status} | ${pct}% | ${taskInfo} |`;
+  }).join("\n");
+  const alertList = alerts || [];
+  const alertRows = alertList.map(
+    (a) => `| ${a.title} | ${a.priority} | ${a.status} | ${typeof a.createdAt === "string" ? a.createdAt.split("T")[0] : ""} |`
+  ).join("\n");
+  const stats = taskStats || { total: 0, completed: 0, inProgress: 0, blocked: 0, overdue: 0 };
+  const healthIndicators = [];
+  if (stats.overdue > 0) healthIndicators.push(`${stats.overdue} overdue tasks`);
+  if (stats.blocked > 0) healthIndicators.push(`${stats.blocked} blocked tasks`);
+  if (alertList.length > 0) healthIndicators.push(`${alertList.length} active alerts`);
+  if (totalBudgetHours > 0 && hoursUsed > totalBudgetHours * 0.9) healthIndicators.push("Budget burn > 90%");
+  return `# Project Health Report
+Project: ${project.name}
+Client: ${project.client?.name || "N/A"}
+Status: ${project.status}
+Phase: ${project.lifecycleStage || "N/A"}
+${args.includeForecasts === "true" ? "Forecasting: Enabled" : ""}
+
+## Health Indicators
+${healthIndicators.length > 0 ? healthIndicators.map((h) => `- WARNING: ${h}`).join("\n") : "- No issues detected"}
+
+## Budget
+- Total budget: $${totalBudget.toLocaleString()} / ${totalBudgetHours}h
+- Hours used: ${hoursUsed.toFixed(1)}h (${budgetBurnPct}%)
+- Billable hours: ${timeData.billableHours.toFixed(1)}h
+- Time entries: ${timeData.entries.length}
+
+## Timeline
+- Start: ${startDate ? startDate.toISOString().split("T")[0] : "Not set"}
+- End: ${endDate ? endDate.toISOString().split("T")[0] : "Not set"}
+- Elapsed: ${timelineElapsedPct}%
+
+## Tasks
+| Metric | Count |
+|--------|-------|
+| Total | ${stats.total} |
+| Completed | ${stats.completed} |
+| In Progress | ${stats.inProgress} |
+| Blocked | ${stats.blocked} |
+| Overdue | ${stats.overdue} |
+
+## Deliverables
+| Name | Status | Progress | Tasks |
+|------|--------|----------|-------|
+${deliverableDetails || "| No deliverables | - | - | - |"}
+
+## Team (${teamMembers.length} members)
+${teamMembers.map((m) => `- ${m.name} (${m.hoursPerWeek}h/week)`).join("\n") || "- No team allocations"}
+
+## Alerts & Risks
+| Title | Priority | Status | Created |
+|-------|----------|--------|---------|
+${alertRows || "| No active alerts | - | - | - |"}
+
+Based on this data, please:
+1. Assign an overall health rating (GREEN / AMBER / RED) with justification
+2. Identify the top 3 risks
+3. Provide specific actionable recommendations
+${args.includeForecasts === "true" ? "4. Forecast budget at completion and projected end date" : ""}`;
+}
+
+// src/prompts/meeting-prep.ts
+var meeting_prep_exports = {};
+__export(meeting_prep_exports, {
+  generate: () => generate4
+});
+async function generate4(args) {
+  const data = await fetchClientActivity(args.clientId, 14);
+  if (!data) return `Client ${args.clientId} not found.`;
+  const { client, recentEntries, openTasks, invoices } = data;
+  const meetingType = args.meetingType || "status";
+  const globalContacts = client.globalContacts || [];
+  const contactsList = globalContacts.length > 0 ? globalContacts.map((c) => `- ${c.firstName || ""} ${c.lastName || ""} \u2014 ${c.title || "N/A"} (${c.role || "N/A"}) \u2014 ${c.email || "No email"}`).join("\n") : "- No contacts on file";
+  const projects = client.projects || [];
+  const projectsList = projects.length > 0 ? projects.map((p) => {
+    const deliverables = p.deliverables || [];
+    const delStatus = deliverables.map((d) => `${d.name}: ${d.status} (${Number(d.percentComplete || 0)}%)`).join(", ");
+    return `- ${p.name} [${p.status}/${p.lifecycleStage || "N/A"}] \u2014 Value: $${Number(p.proposalValue || 0).toLocaleString()}
+  Deliverables: ${delStatus || "None"}`;
+  }).join("\n") : "- No active projects";
+  const entries = recentEntries || [];
+  const recentHours = entries.reduce((sum, e) => sum + Number(e.hours), 0);
+  const activityList = entries.length > 0 ? entries.slice(0, 20).map((e) => {
+    const date = typeof e.entryDate === "string" ? e.entryDate.split("T")[0] : (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const who = e.person?.name || "Unknown";
+    return `- ${date}: ${who} \u2014 ${e.project?.name || ""} / ${e.task?.name || "General"} (${Number(e.hours)}h) ${e.description || ""}`;
+  }).join("\n") : "- No recent activity";
+  const tasks = openTasks || [];
+  const openItemsList = tasks.length > 0 ? tasks.slice(0, 20).map((t) => {
+    const due = t.endDate ? typeof t.endDate === "string" ? t.endDate.split("T")[0] : "No date" : "No date";
+    const assignees = t.assignees || [];
+    const owner = assignees.map((a) => a.name).filter(Boolean).join(", ") || "Unassigned";
+    return `| ${t.name} | ${owner} | ${due} | ${t.status} |`;
+  }).join("\n") : "| No open items | - | - | - |";
+  const invoiceList = invoices || [];
+  const totalOutstanding = invoiceList.reduce((sum, i) => sum + Number(i.total || 0), 0);
+  const invoiceListStr = invoiceList.length > 0 ? invoiceList.map((i) => `- ${i.invoiceNumber || i.id}: $${Number(i.total || 0).toLocaleString()} (${i.status}) due ${i.dueDate ? typeof i.dueDate === "string" ? i.dueDate.split("T")[0] : "N/A" : "N/A"}`).join("\n") : "- No outstanding invoices";
+  const talkingPoints = {
+    kickoff: `- Project scope and objectives
+- Team introductions and roles
+- Communication cadence and tools
+- Success criteria and KPIs
+- Timeline and key milestones
+- Risk management approach`,
+    status: `- Progress since last meeting
+- Upcoming milestones and deadlines
+- Resource needs or changes
+- Risks and mitigation actions
+- Client decisions needed`,
+    review: `- Deliverables walkthrough
+- Quality and acceptance criteria
+- Lessons learned
+- Scope changes or CR discussion
+- Next phase planning`,
+    escalation: `- Issue summary and timeline
+- Impact assessment (schedule, budget, quality)
+- Root cause analysis
+- Proposed resolution options
+- Prevention measures for future`
+  };
+  return `# Meeting Preparation Brief
+Client: ${client.name}
+${args.projectId ? `Project filter: ${args.projectId}` : "All Projects"}
+Meeting Type: ${meetingType}
+
+## Client Context
+- Industry: ${client.industry || "N/A"}
+- Health Score: ${client.healthScore || "N/A"}
+- Active projects: ${projects.length}
+
+## Key Contacts
+${contactsList}
+
+## Projects Overview
+${projectsList}
+
+## Recent Activity (Last 2 Weeks)
+Total hours logged: ${recentHours.toFixed(1)}h
+${activityList}
+
+## Open Items & Action Items
+| Item | Owner | Due | Status |
+|------|-------|-----|--------|
+${openItemsList}
+
+## Financial Summary
+- Outstanding invoices: $${totalOutstanding.toLocaleString()}
+${invoiceListStr}
+
+## Suggested Talking Points (${meetingType})
+${talkingPoints[meetingType] || talkingPoints.status}
+
+Based on this data, please:
+1. Draft a concise meeting agenda (5-7 items)
+2. Highlight the top 3 things to discuss with the client
+3. Note any risks or sensitive topics to be aware of
+4. Suggest any documents or materials to bring`;
+}
+
+// src/prompts/compliance-check.ts
+var compliance_check_exports = {};
+__export(compliance_check_exports, {
+  generate: () => generate5
+});
+async function generate5(args) {
+  const daysAhead = parseInt(args.daysAhead || "30", 10);
+  const expiring = await fetchExpiringCredentials(daysAhead);
+  const result = await apiGet("/prompts/credentials/all");
+  const allCredentials = result.credentials;
+  const statusCounts = {
+    verified: allCredentials.filter((c) => c.status === "VERIFIED").length,
+    expiringSoon: allCredentials.filter((c) => c.status === "EXPIRING_SOON").length,
+    expired: allCredentials.filter((c) => c.status === "EXPIRED").length,
+    pendingUpload: allCredentials.filter((c) => c.status === "PENDING_UPLOAD").length,
+    pendingVerification: allCredentials.filter((c) => c.status === "PENDING_VERIFICATION").length,
+    rejected: allCredentials.filter((c) => c.status === "REJECTED").length,
+    suspended: allCredentials.filter((c) => c.status === "SUSPENDED").length
+  };
+  const total = allCredentials.length;
+  const complianceScore = total > 0 ? (statusCounts.verified / total * 100).toFixed(1) : "N/A";
+  let complianceItems = "- No project filter applied; showing org-wide credentials";
+  if (args.projectId) {
+    const itemsResult = await apiGet(`/prompts/projects/${args.projectId}/compliance`);
+    complianceItems = itemsResult.items.length > 0 ? itemsResult.items.map((i) => `| ${i.name} | ${i.type || "N/A"} | ${i.status} | ${i.dueDate || "N/A"} |`).join("\n") : "- No compliance items for this project";
+  }
+  const expiringList = expiring.length > 0 ? expiring.map((c) => `| ${c.person?.name || "Unknown"} | ${c.name} | ${c.type} | ${c.expiresAt || "N/A"} | ${c.daysUntilExpiry ?? "N/A"} days |`).join("\n") : "| No credentials expiring within window | - | - | - | - |";
+  return `# Compliance Status Review
+${args.projectId ? `Project: ${args.projectId}` : "Scope: Organization-wide"}
+Look-ahead window: ${daysAhead} days
+
+## Credential Summary
+| Status | Count |
+|--------|-------|
+| Verified | ${statusCounts.verified} |
+| Expiring Soon | ${statusCounts.expiringSoon} |
+| Expired | ${statusCounts.expired} |
+| Pending Upload | ${statusCounts.pendingUpload} |
+| Pending Verification | ${statusCounts.pendingVerification} |
+| Rejected | ${statusCounts.rejected} |
+| Suspended | ${statusCounts.suspended} |
+| **Total** | **${total}** |
+
+## Compliance Score: ${complianceScore}%
+
+## Expiring Credentials (within ${daysAhead} days)
+| Person | Credential | Type | Expires | Time Left |
+|--------|------------|------|---------|-----------|
+${expiringList}
+
+${args.projectId ? `## Project Compliance Items
+| Name | Type | Status | Expiry |
+|------|------|--------|--------|
+${complianceItems}` : ""}
+
+Based on this data, please:
+1. Identify the most urgent compliance actions needed
+2. Flag any team members who may become non-compliant
+3. Recommend a prioritized remediation plan
+4. Note any patterns (e.g., multiple credentials expiring at once)`;
+}
+
+// src/prompts/resource-plan.ts
+var resource_plan_exports = {};
+__export(resource_plan_exports, {
+  generate: () => generate6
+});
+async function generate6(args) {
+  const timeframeWeeks = parseInt(args.timeframe || "4", 10);
+  const data = await fetchProjectWithDetails(args.projectId);
+  if (!data) return `Project ${args.projectId} not found.`;
+  const { project, taskStats } = data;
+  const startDate = /* @__PURE__ */ new Date();
+  const endDate = /* @__PURE__ */ new Date();
+  endDate.setDate(endDate.getDate() + timeframeWeeks * 7);
+  const availability = await fetchTeamAvailability(startDate, endDate);
+  const teamResult = await apiGet("/prompts/team");
+  const team = teamResult.team;
+  const personAllocation = team.map((p) => {
+    const totalAllocated = p.allocations.reduce((sum, a) => sum + Number(a.hoursPerWeek || 0), 0);
+    const projectAlloc = p.allocations.find((a) => a.project.name === project.name);
+    return {
+      name: p.name,
+      role: p.role,
+      totalAllocatedHours: totalAllocated,
+      thisProjectHours: Number(projectAlloc?.hoursPerWeek || 0),
+      otherProjects: p.allocations.filter((a) => a.project.name !== project.name).map((a) => `${a.project.name} (${Number(a.hoursPerWeek || 0)}h)`),
+      topSkills: p.capabilities.slice(0, 5).map((c) => `${c.name} (${c.proficiency})`)
+    };
+  });
+  const availSummary = {};
+  for (const day of availability.days) {
+    const name = day.person.name;
+    if (!availSummary[name]) availSummary[name] = { available: 0, leave: 0, partial: 0 };
+    if (day.status === "AVAILABLE") availSummary[name].available++;
+    if (day.status === "LEAVE") availSummary[name].leave++;
+    if (day.status === "PARTIALLY_AVAILABLE") availSummary[name].partial++;
+  }
+  const utilRows = availability.utilization.length > 0 ? availability.utilization.map((u) => {
+    return `| ${u.person.name} | ${u.weekStart.split("T")[0]} | ${Number(u.billableHours || 0)}h | ${Number(u.availableHours || 0)}h | ${Number(u.utilizationRate || 0).toFixed(0)}% |`;
+  }).join("\n") : "| No utilization data | - | - | - | - |";
+  const allocationTable = personAllocation.filter((p) => p.totalAllocatedHours > 0 || p.thisProjectHours > 0).map((p) => `| ${p.name} | ${p.role || "N/A"} | ${p.thisProjectHours}h | ${p.totalAllocatedHours}h | ${p.otherProjects.join(", ") || "None"} |`).join("\n") || "| No allocations | - | - | - | - |";
+  const typedProject = project;
+  return `# Resource Allocation Plan
+Project: ${project.name}
+Client: ${typedProject.client?.name || typedProject.clientName || "N/A"}
+Timeframe: ${timeframeWeeks} weeks (${startDate.toISOString().split("T")[0]} to ${endDate.toISOString().split("T")[0]})
+
+## Project Status
+- Tasks: ${taskStats?.total || 0} total (${taskStats?.inProgress || 0} in progress, ${taskStats?.blocked || 0} blocked)
+- Overdue tasks: ${taskStats?.overdue || 0}
+- Team size: ${typedProject.allocations?.length || 0} allocated
+
+## Current Team Allocation
+| Person | Role | This Project | Total Allocated | Other Projects |
+|--------|------|-------------|-----------------|----------------|
+${allocationTable}
+
+## Availability (next ${timeframeWeeks} weeks)
+${Object.entries(availSummary).map(
+    ([name, s]) => `- ${name}: ${s.available} available days, ${s.leave} leave days, ${s.partial} partial days`
+  ).join("\n") || "- No availability data recorded"}
+
+## Utilization Records
+| Person | Week | Billable | Available | Rate |
+|--------|------|----------|-----------|------|
+${utilRows}
+
+## Team Capabilities
+${team.filter((p) => p.capabilities.length > 0).map(
+    (p) => `- ${p.name}: ${p.capabilities.map((c) => `${c.name} (${c.proficiency})`).join(", ")}`
+  ).join("\n") || "- No capability data recorded"}
+
+Based on this data, please:
+1. Assess whether the project is adequately resourced
+2. Identify capacity gaps or over-allocation risks
+3. Recommend specific staffing adjustments
+4. Flag any upcoming availability conflicts (leave, competing projects)`;
+}
+
+// src/prompts/risk-assessment.ts
+var risk_assessment_exports = {};
+__export(risk_assessment_exports, {
+  generate: () => generate7
+});
+async function generate7(args) {
+  const data = await fetchProjectWithDetails(args.projectId);
+  if (!data) return `Project ${args.projectId} not found.`;
+  const { project, alerts, taskStats, allTasks } = data;
+  const now = /* @__PURE__ */ new Date();
+  const riskMemories = await fetchRiskMemories(args.projectId);
+  const tasks = allTasks || [];
+  const overdueTasks = tasks.filter((t) => t.endDate && new Date(t.endDate) < now && t.status !== "COMPLETED").map((t) => ({
+    name: t.name,
+    dueDate: typeof t.endDate === "string" ? t.endDate.split("T")[0] : "",
+    daysOverdue: Math.ceil((now.getTime() - new Date(t.endDate).getTime()) / (1e3 * 60 * 60 * 24)),
+    status: t.status
+  }));
+  const complianceResult = await apiGet(`/prompts/projects/${args.projectId}/compliance/issues`);
+  const complianceIssues = complianceResult.items || [];
+  const completedTasks = tasks.filter((t) => t.status === "COMPLETED");
+  const sortedCompleted = completedTasks.sort((a, b) => {
+    const aTime = a.endDate ? new Date(a.endDate).getTime() : 0;
+    const bTime = b.endDate ? new Date(b.endDate).getTime() : 0;
+    return bTime - aTime;
+  });
+  const latestTask = sortedCompleted[0];
+  const daysSinceActivity = latestTask?.endDate ? Math.ceil((now.getTime() - new Date(latestTask.endDate).getTime()) / (1e3 * 60 * 60 * 24)) : null;
+  const stats = taskStats || { total: 0, completed: 0, inProgress: 0, blocked: 0, overdue: 0 };
+  const alertList = alerts || [];
+  const riskFactors = [];
+  if (stats.overdue > 0) riskFactors.push(`${stats.overdue} overdue tasks`);
+  if (stats.blocked > 0) riskFactors.push(`${stats.blocked} blocked tasks`);
+  if (alertList.length > 0) riskFactors.push(`${alertList.length} active alerts`);
+  if (complianceIssues.length > 0) riskFactors.push(`${complianceIssues.length} compliance issues`);
+  if (daysSinceActivity && daysSinceActivity > 14) riskFactors.push(`${daysSinceActivity} days since last completed task`);
+  const alertsList = alertList.length > 0 ? alertList.map((a) => `| ${a.title} | ${a.priority} | ${a.status} | ${typeof a.createdAt === "string" ? a.createdAt.split("T")[0] : ""} |`).join("\n") : "| No active alerts | - | - | - |";
+  const overdueList = overdueTasks.length > 0 ? overdueTasks.map((t) => `| ${t.name} | ${t.dueDate} | ${t.daysOverdue} days | ${t.status} |`).join("\n") : "| No overdue tasks | - | - | - |";
+  const complianceList = complianceIssues.length > 0 ? complianceIssues.map((c) => `| ${c.name} | ${c.status} | ${c.dueDate ? typeof c.dueDate === "string" ? c.dueDate.split("T")[0] : "N/A" : "N/A"} |`).join("\n") : "| No compliance issues | - | - |";
+  const memoriesList = riskMemories.length > 0 ? riskMemories.map((m) => `- [${m.category}] ${m.content} (confidence: ${m.confidence})`).join("\n") : "- No risk memories recorded";
+  const typedProject = project;
+  return `# Risk Assessment
+Project: ${project.name}
+Client: ${typedProject.client?.name || "N/A"}
+Date: ${now.toISOString().split("T")[0]}
+
+## Risk Summary
+Risk factors identified: ${riskFactors.length}
+${riskFactors.length > 0 ? riskFactors.map((r) => `- WARNING: ${r}`).join("\n") : "- No immediate risk factors"}
+
+## Active Alerts
+| Title | Priority | Status | Created |
+|-------|----------|--------|---------|
+${alertsList}
+
+## Overdue Tasks
+| Task | Due Date | Days Overdue | Status |
+|------|----------|-------------|--------|
+${overdueList}
+
+## Compliance Issues
+| Item | Status | Expiry |
+|------|--------|--------|
+${complianceList}
+
+## Project Activity
+- Last completed task: ${latestTask ? `${latestTask.name} (${latestTask.endDate ? typeof latestTask.endDate === "string" ? latestTask.endDate.split("T")[0] : "" : "N/A"})` : "None"}
+- Days since activity: ${daysSinceActivity ?? "N/A"}
+${daysSinceActivity && daysSinceActivity > 14 ? "- WARNING: Project may be stale" : ""}
+
+## AI Agent Risk Memories
+${memoriesList}
+
+## Task Health
+- Total: ${stats.total} | Completed: ${stats.completed} | Blocked: ${stats.blocked} | Overdue: ${stats.overdue}
+
+Based on this data, please:
+1. Rate overall risk level (LOW / MEDIUM / HIGH / CRITICAL)
+2. Create a prioritized risk register with likelihood, impact, and owner
+3. Recommend specific mitigation actions for each risk
+4. Identify any emerging risk patterns`;
+}
+
+// src/prompts/pipeline-review.ts
+var pipeline_review_exports = {};
+__export(pipeline_review_exports, {
+  generate: () => generate8
+});
+async function generate8(args) {
+  const data = await fetchPipelineData(args.stage);
+  const projects = data.projects || [];
+  const totalValue = projects.reduce((sum, p) => sum + Number(p.proposalValue || 0), 0);
+  const stageTable = (data.stageStats || []).length > 0 ? data.stageStats.map((s) => `| ${s.stage} | ${s.count} | $${s.totalValue.toLocaleString()} | ${s.avgAgeDays} |`).join("\n") : "| No pipeline data | - | - | - |";
+  const now = /* @__PURE__ */ new Date();
+  const staleOpps = projects.filter((p) => {
+    const updatedAt = p.updatedAt ? new Date(p.updatedAt) : now;
+    const ageDays = (now.getTime() - updatedAt.getTime()) / (1e3 * 60 * 60 * 24);
+    return ageDays > 30;
+  });
+  const staleList = staleOpps.length > 0 ? staleOpps.map((p) => {
+    const updatedAt = p.updatedAt ? new Date(p.updatedAt) : now;
+    const staleDays = Math.ceil((now.getTime() - updatedAt.getTime()) / (1e3 * 60 * 60 * 24));
+    return `| ${p.name} | ${p.client?.name || p.clientName || "N/A"} | ${p.lifecycleStage} | $${Number(p.proposalValue || 0).toLocaleString()} | ${staleDays} days |`;
+  }).join("\n") : "| No stale opportunities | - | - | - | - |";
+  const oppList = projects.map((p) => {
+    const createdAt = p.createdAt ? new Date(p.createdAt) : now;
+    const age = Math.ceil((now.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24));
+    return `| ${p.name} | ${p.client?.name || p.clientName || "N/A"} | ${p.lifecycleStage} | $${Number(p.proposalValue || 0).toLocaleString()} | ${p.status} | ${age}d |`;
+  }).join("\n") || "| No opportunities | - | - | - | - | - |";
+  return `# Pipeline Health Review
+${args.stage ? `Stage Filter: ${args.stage}` : "All Stages"}
+Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+
+## Pipeline Summary
+- Total opportunities: ${data.totalCount}
+- Total value: $${totalValue.toLocaleString()}
+- Stale opportunities (>30 days): ${staleOpps.length}
+
+## Stage Breakdown
+| Stage | Count | Value | Avg Age (days) |
+|-------|-------|-------|----------------|
+${stageTable}
+
+## All Opportunities
+| Name | Client | Stage | Value | Status | Age |
+|------|--------|-------|-------|--------|-----|
+${oppList}
+
+## At-Risk Opportunities (Stale >30 days)
+| Name | Client | Stage | Value | Stale Days |
+|------|--------|-------|-------|------------|
+${staleList}
+
+Based on this data, please:
+1. Assess overall pipeline health and velocity
+2. Identify opportunities that need immediate attention
+3. Recommend next actions for stale or at-risk opportunities
+4. Suggest pipeline optimization strategies`;
+}
+
+// src/prompts/invoice-draft.ts
+var invoice_draft_exports = {};
+__export(invoice_draft_exports, {
+  generate: () => generate9
+});
+async function generate9(args) {
+  const clientResult = await apiGet(`/prompts/clients/${args.clientId}`);
+  const client = clientResult.client;
+  if (!client) return `Client ${args.clientId} not found.`;
+  const options = {};
+  if (args.projectId) options.projectId = args.projectId;
+  if (args.fromDate) options.fromDate = new Date(args.fromDate);
+  if (args.toDate) options.toDate = new Date(args.toDate);
+  const data = await fetchUnbilledTime(args.clientId, options);
+  const byProject = {};
+  for (const entry of data.entries) {
+    const pid = entry.project?.id || "unknown";
+    if (!byProject[pid]) byProject[pid] = { projectName: entry.project?.name || "Unknown", entries: [] };
+    byProject[pid].entries.push(entry);
+  }
+  const entryRows = data.entries.length > 0 ? data.entries.map((e) => {
+    const date = e.entryDate.split("T")[0];
+    const person = e.person?.name || "Unknown";
+    const proj = e.project?.name || "Unknown";
+    const task = e.task?.name || "General";
+    return `| ${date} | ${person} | ${proj} | ${task} | ${Number(e.hours)} | - | - |`;
+  }).join("\n") : "| No unbilled entries found | - | - | - | - | - | - |";
+  const projectSummary = Object.entries(byProject).map(([_pid, { projectName, entries }]) => {
+    const hours = entries.reduce((sum, e) => sum + Number(e.hours), 0);
+    return `### ${projectName}
+- Hours: ${hours.toFixed(1)}h
+- Entries: ${entries.length}`;
+  }).join("\n\n");
+  return `# Invoice Draft
+Client: ${client.name}
+${args.projectId ? `Project: ${args.projectId}` : "All Projects"}
+Billing Period: ${args.fromDate || "Start of unbilled"} to ${args.toDate || "Today"}
+
+## Unbilled Time Entries
+| Date | Team Member | Project | Task | Hours | Rate | Amount |
+|------|-------------|---------|------|-------|------|--------|
+${entryRows}
+
+## Summary
+- Total unbilled hours: ${data.totalHours.toFixed(1)}h
+- Number of entries: ${data.entries.length}
+- Projects: ${data.projects.length}
+
+## Line Items (Grouped by Project)
+${projectSummary || "- No entries to group"}
+
+## Notes
+- Client: ${client.name}
+- Industry: ${client.industry || "N/A"}
+
+Based on this data, please:
+1. Calculate estimated amounts using standard billing rates (or note that rates need to be provided)
+2. Draft professional invoice line items grouped by project
+3. Include a summary table with subtotals per project
+4. Note any entries that may need review (e.g., unusually high hours, missing descriptions)
+5. Suggest payment terms and any special billing notes`;
+}
+
+// src/prompts/client-update.ts
+var client_update_exports = {};
+__export(client_update_exports, {
+  generate: () => generate10
+});
+async function generate10(args) {
+  const data = await fetchClientActivity(args.clientId, 14);
+  if (!data) return `Client ${args.clientId} not found.`;
+  const { client, recentEntries, openTasks } = data;
+  const topic = args.topic || "General Update";
+  const projects = client.projects || [];
+  const deliverables = projects.flatMap(
+    (p) => (p.deliverables || []).map((d) => ({
+      projectName: p.name,
+      name: d.name,
+      status: d.status,
+      progress: Number(d.percentComplete || 0)
+    }))
+  );
+  const recentActivity = (recentEntries || []).length > 0 ? (recentEntries || []).slice(0, 15).map((e) => {
+    const date = typeof e.entryDate === "string" ? e.entryDate.split("T")[0] : (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return `- ${date}: ${e.project?.name || ""} \u2014 ${e.description || e.task?.name || "Work performed"} (${Number(e.hours)}h)`;
+  }).join("\n") : "- No recent activity to report";
+  const deliverablesList = deliverables.length > 0 ? deliverables.map((d) => `- ${d.projectName} / ${d.name}: ${d.status} (${d.progress}%)`).join("\n") : "- No deliverables to report";
+  const now = /* @__PURE__ */ new Date();
+  const upcomingItems = (openTasks || []).filter((t) => t.endDate && new Date(t.endDate) > now).slice(0, 10).map((t) => `- ${t.name} \u2014 due ${typeof t.endDate === "string" ? t.endDate.split("T")[0] : ""}`).join("\n") || "- No upcoming items";
+  const globalContacts = client.globalContacts || [];
+  const primaryContact = globalContacts[0];
+  return `# Client Update Draft
+Client: ${client.name}
+Topic: ${topic}
+${primaryContact ? `Primary Contact: ${primaryContact.firstName || ""} ${primaryContact.lastName || ""} (${primaryContact.title || "N/A"})` : ""}
+
+## Context Data
+
+### Recent Activity (Last 2 Weeks)
+${recentActivity}
+
+### Deliverable Status
+${deliverablesList}
+
+### Upcoming Milestones
+${upcomingItems}
+
+### Active Projects
+${projects.map((p) => `- ${p.name}: ${p.status} (${p.lifecycleStage || "N/A"})`).join("\n") || "- None"}
+
+Based on this data, please draft a professional client update email that:
+1. Opens with a brief, warm greeting${primaryContact ? ` to ${primaryContact.firstName || ""}` : ""}
+2. Summarizes progress on the topic: "${topic}"
+3. Highlights key deliverables and their status
+4. Notes upcoming milestones or deadlines
+5. Calls out any items needing client input or decisions
+6. Closes professionally with next steps`;
+}
+
+// src/prompts/handoff-notes.ts
+var handoff_notes_exports = {};
+__export(handoff_notes_exports, {
+  generate: () => generate11
+});
+async function generate11(args) {
+  const data = await fetchProjectWithDetails(args.projectId);
+  if (!data) return `Project ${args.projectId} not found.`;
+  const { project, taskStats } = data;
+  const fromPerson = await fetchPersonByUserId(args.fromUserId);
+  const toPerson = args.toUserId ? await fetchPersonByUserId(args.toUserId) : null;
+  const scope = args.scope || "full";
+  const fromTasks = fromPerson ? await fetchPersonTasks(fromPerson.id, {
+    status: ["NOT_STARTED", "IN_PROGRESS", "BLOCKED"]
+  }) : [];
+  const projectTasks = fromTasks.filter((t) => t.project?.id === args.projectId);
+  const decisions = await fetchProjectDecisions(args.projectId);
+  const clientId = project.clientId;
+  let contacts = [];
+  if (clientId) {
+    const contactsResult = await apiGet(`/prompts/clients/${clientId}/contacts`);
+    contacts = contactsResult.contacts;
+  }
+  const documentsResult = await apiGet(`/prompts/projects/${args.projectId}/documents`);
+  const documents = documentsResult.documents;
+  const memoriesResult = await apiGet(`/prompts/projects/${args.projectId}/memories`);
+  const memories = memoriesResult.memories;
+  const taskTable = projectTasks.length > 0 ? projectTasks.map((t) => {
+    const due = t.endDate ? t.endDate.split("T")[0] : "No date";
+    return `| ${t.name} | ${t.status} | ${due} | ${(t.description || "").slice(0, 80) || "N/A"} |`;
+  }).join("\n") : "| No assigned tasks | - | - | - |";
+  const decisionList = decisions.length > 0 ? decisions.map((d) => `- ${d.createdAt.split("T")[0]}: **${d.title}** \u2014 ${d.decision}
+  Rationale: ${d.rationale || "N/A"}`).join("\n") : "- No decisions recorded";
+  const contactList = contacts.length > 0 ? contacts.map((c) => `- ${c.firstName || ""} ${c.lastName || ""} (${c.title || "N/A"}, ${c.role || "N/A"}) \u2014 ${c.email || "No email"}`).join("\n") : "- No contacts on file";
+  const docList = documents.length > 0 ? documents.map((d) => `- ${d.name || d.title} [${d.type || "N/A"}] \u2014 ${d.status} (updated ${d.updatedAt?.split("T")[0] || "N/A"})`).join("\n") : "- No documents";
+  const tribalKnowledge = memories.length > 0 ? memories.map((m) => `- [${m.category}] ${m.content}`).join("\n") : "- No agent memories recorded for this project";
+  const typedProject = project;
+  return `# Handoff Notes
+Project: ${project.name}
+Client: ${typedProject.client?.name || typedProject.clientName || "N/A"}
+From: ${fromPerson?.name || args.fromUserId}
+To: ${toPerson?.name || args.toUserId || "TBD"}
+Scope: ${scope}
+
+## Project Overview
+- Status: ${project.status}
+- Phase: ${project.lifecycleStage || "N/A"}
+- Start: ${project.startDate?.split("T")[0] || "Not set"}
+- End: ${project.endDate?.split("T")[0] || "Not set"}
+- Tasks: ${taskStats?.total || 0} total (${taskStats?.completed || 0} completed, ${taskStats?.inProgress || 0} in progress, ${taskStats?.blocked || 0} blocked)
+
+## In-Progress Tasks (assigned to ${fromPerson?.name || "outgoing person"})
+| Task | Status | Due | Notes |
+|------|--------|-----|-------|
+${taskTable}
+
+## Key Decisions Made
+${decisionList}
+
+## Key Contacts
+${contactList}
+
+## Important Documents
+${docList}
+
+## Tribal Knowledge (Agent Memories)
+${tribalKnowledge}
+
+Based on this data, please:
+1. Write a concise handoff summary (what the new person needs to know most urgently)
+2. List the top 3 priority items the incoming person should address first
+3. Highlight any open risks, blockers, or sensitive topics
+4. Suggest a recommended first-week action plan`;
+}
+
+// src/prompts/capability-gap.ts
+var capability_gap_exports = {};
+__export(capability_gap_exports, {
+  generate: () => generate12
+});
+async function generate12(args) {
+  const result = await apiGet("/prompts/capabilities");
+  const capabilities = result.capabilities;
+  const matrix = {};
+  for (const cap of capabilities) {
+    const cat = cap.category;
+    const name = cap.name;
+    if (!matrix[cat]) matrix[cat] = {};
+    if (!matrix[cat][name]) matrix[cat][name] = [];
+    matrix[cat][name].push({
+      person: cap.person.name,
+      proficiency: cap.proficiency,
+      evidenced: cap.evidenced
+    });
+  }
+  const singlePoints = [];
+  for (const [cat, caps] of Object.entries(matrix)) {
+    for (const [name, people] of Object.entries(caps)) {
+      if (people.length === 1) {
+        singlePoints.push({ category: cat, capability: name, person: people[0].person });
+      }
+    }
+  }
+  const projectsResult = await apiGet("/prompts/projects/active");
+  const activeProjects = projectsResult.projects;
+  const proficiencyCounts = { NOVICE: 0, COMPETENT: 0, PROFICIENT: 0, EXPERT: 0 };
+  for (const cap of capabilities) {
+    if (proficiencyCounts[cap.proficiency] !== void 0) {
+      proficiencyCounts[cap.proficiency]++;
+    }
+  }
+  const matrixOutput = Object.entries(matrix).map(([cat, caps]) => {
+    const rows = Object.entries(caps).map(([name, people]) => {
+      const peopleStr = people.map((p) => `${p.person} (${p.proficiency}${p.evidenced ? ", evidenced" : ""})`).join(", ");
+      return `| ${name} | ${people.length} | ${peopleStr} |`;
+    }).join("\n");
+    return `### ${cat}
+| Capability | Coverage | People |
+|-----------|----------|--------|
+${rows}`;
+  }).join("\n\n");
+  const spofList = singlePoints.length > 0 ? singlePoints.map((s) => `| ${s.capability} | ${s.category} | ${s.person} |`).join("\n") : "| No single points of failure | - | - |";
+  const uniqueCapabilities = new Set(capabilities.map((c) => c.name)).size;
+  const uniquePeople = new Set(capabilities.map((c) => c.person.id)).size;
+  return `# Capability Gap Analysis
+Organization Scope
+Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+
+## Overview
+- Total capability entries: ${capabilities.length}
+- Unique capabilities: ${uniqueCapabilities}
+- People with capabilities: ${uniquePeople}
+- Categories: ${Object.keys(matrix).length}
+
+## Proficiency Distribution
+| Level | Count |
+|-------|-------|
+| Expert | ${proficiencyCounts.EXPERT} |
+| Proficient | ${proficiencyCounts.PROFICIENT} |
+| Competent | ${proficiencyCounts.COMPETENT} |
+| Novice | ${proficiencyCounts.NOVICE} |
+
+## Capability Matrix
+${matrixOutput || "- No capabilities recorded"}
+
+## Single Points of Failure (only 1 person)
+| Capability | Category | Person |
+|-----------|----------|--------|
+${spofList}
+
+## Active Project Types
+${activeProjects.map((p) => {
+    const types = [...new Set((p.deliverables || []).map((d) => d.type))];
+    return `- ${p.name}: ${types.join(", ") || "No deliverables"}`;
+  }).join("\n") || "- No active projects"}
+
+Based on this data, please:
+1. Identify the most critical capability gaps (considering project needs)
+2. Highlight single points of failure that pose business risk
+3. Recommend training or hiring priorities
+4. Suggest cross-training opportunities to improve coverage`;
+}
+
+// src/prompts/team-availability.ts
+var team_availability_exports = {};
+__export(team_availability_exports, {
+  generate: () => generate13
+});
+async function generate13(args) {
+  const weeksAhead = parseInt(args.weeks || "2", 10);
+  const startDate = /* @__PURE__ */ new Date();
+  startDate.setHours(0, 0, 0, 0);
+  const endDate = /* @__PURE__ */ new Date();
+  endDate.setDate(endDate.getDate() + weeksAhead * 7);
+  const { days, utilization } = await fetchTeamAvailability(startDate, endDate);
+  const peopleResult = await apiGet("/prompts/people");
+  const people = peopleResult.people;
+  const personSummary = people.map((p) => {
+    const personDays = days.filter((d) => d.person.id === p.id);
+    const available = personDays.filter((d) => d.status === "AVAILABLE").length;
+    const leave = personDays.filter((d) => d.status === "LEAVE").length;
+    const partial = personDays.filter((d) => d.status === "PARTIALLY_AVAILABLE").length;
+    const unavailable = personDays.filter((d) => d.status === "UNAVAILABLE").length;
+    const holiday = personDays.filter((d) => d.status === "PUBLIC_HOLIDAY").length;
+    const totalAllocated = p.allocations.reduce((sum, a) => sum + Number(a.hoursPerWeek || 0), 0);
+    return {
+      name: p.name,
+      available,
+      leave,
+      partial,
+      unavailable,
+      holiday,
+      totalDays: personDays.length,
+      allocatedHoursPerWeek: totalAllocated,
+      projects: p.allocations.map((a) => `${a.project.name} (${Number(a.hoursPerWeek || 0)}h)`)
+    };
+  });
+  const leaveDays = days.filter((d) => d.status === "LEAVE" || d.status === "UNAVAILABLE").map((d) => `| ${d.person.name} | ${d.date.split("T")[0]} | ${d.status} | ${d.notes || ""} |`);
+  const utilRows = utilization.map((u) => {
+    return `| ${u.person.name} | ${u.weekStart.split("T")[0]} | ${Number(u.billableHours || 0)}h | ${Number(u.nonBillableHours || 0)}h | ${Number(u.leaveHours || 0)}h | ${Number(u.utilizationRate || 0).toFixed(0)}% |`;
+  });
+  const summaryTable = personSummary.map(
+    (p) => `| ${p.name} | ${p.available} | ${p.leave} | ${p.partial} | ${p.unavailable} | ${p.allocatedHoursPerWeek}h | ${p.projects.join(", ") || "None"} |`
+  ).join("\n");
+  return `# Team Availability Overview
+Period: ${startDate.toISOString().split("T")[0]} to ${endDate.toISOString().split("T")[0]} (${weeksAhead} weeks)
+Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+
+## Team Summary
+| Person | Available | Leave | Partial | Unavailable | Allocated/week | Projects |
+|--------|-----------|-------|---------|-------------|----------------|----------|
+${summaryTable || "| No data | - | - | - | - | - | - |"}
+
+## Upcoming Leave / Unavailability
+| Person | Date | Status | Note |
+|--------|------|--------|------|
+${leaveDays.length > 0 ? leaveDays.join("\n") : "| No leave scheduled | - | - | - |"}
+
+## Utilization Records
+| Person | Week | Billable | Non-Billable | Leave | Rate |
+|--------|------|----------|-------------|-------|------|
+${utilRows.length > 0 ? utilRows.join("\n") : "| No utilization data | - | - | - | - | - |"}
+
+## Key Stats
+- Total team members: ${people.length}
+- People on leave this period: ${personSummary.filter((p) => p.leave > 0).length}
+- Avg allocated hours/week: ${people.length > 0 ? (personSummary.reduce((sum, p) => sum + p.allocatedHoursPerWeek, 0) / people.length).toFixed(1) : 0}h
+
+Based on this data, please:
+1. Identify team members with capacity for additional work
+2. Flag any upcoming coverage gaps or leave conflicts
+3. Highlight anyone who appears over-allocated
+4. Recommend any scheduling adjustments needed`;
+}
+
+// src/prompts/index.ts
+var prompts = [
+  {
+    name: "weekly_status",
+    description: "Generate a weekly status report for a project with real task, time, and deliverable data",
+    arguments: [
+      { name: "projectId", description: "Project ID", required: true },
+      { name: "week", description: "Week number or date range", required: false }
+    ]
+  },
+  {
+    name: "daily_standup",
+    description: "Generate daily standup summary with completed work, planned tasks, and blockers",
+    arguments: [
+      { name: "userId", description: "User ID for the standup", required: true },
+      { name: "date", description: "Date for the standup (defaults to today)", required: false },
+      { name: "projectId", description: "Filter to a specific project", required: false }
+    ]
+  },
+  {
+    name: "project_health",
+    description: "Analyze project health including budget burn, timeline adherence, and risk exposure",
+    arguments: [
+      { name: "projectId", description: "Project ID to analyze", required: true },
+      { name: "includeForecasts", description: "Include budget and timeline forecasts (true/false)", required: false }
+    ]
+  },
+  {
+    name: "meeting_prep",
+    description: "Prepare for a client meeting with recent activity, open items, and talking points",
+    arguments: [
+      { name: "clientId", description: "Client ID for the meeting", required: true },
+      { name: "projectId", description: "Filter to a specific project", required: false },
+      { name: "meetingType", description: "Type of meeting (kickoff, status, review, escalation)", required: false }
+    ]
+  },
+  {
+    name: "compliance_check",
+    description: "Review compliance status and upcoming credential expirations",
+    arguments: [
+      { name: "projectId", description: "Project ID (optional, all if omitted)", required: false },
+      { name: "daysAhead", description: "Look ahead days for expiries (default 30)", required: false }
+    ]
+  },
+  {
+    name: "resource_plan",
+    description: "Generate resource allocation recommendation with availability and capability data",
+    arguments: [
+      { name: "projectId", description: "Project ID", required: true },
+      { name: "timeframe", description: "Planning timeframe in weeks (default 4)", required: false }
+    ]
+  },
+  {
+    name: "risk_assessment",
+    description: "Assess and summarize risks for a project using alerts, tasks, compliance, and agent memories",
+    arguments: [
+      { name: "projectId", description: "Project ID", required: true }
+    ]
+  },
+  {
+    name: "pipeline_review",
+    description: "Analyze pipeline health, stage distribution, and stale opportunities",
+    arguments: [
+      { name: "stage", description: "Filter by lifecycle stage (optional)", required: false }
+    ]
+  },
+  {
+    name: "invoice_draft",
+    description: "Draft an invoice based on unbilled time entries for a client",
+    arguments: [
+      { name: "clientId", description: "Client ID to invoice", required: true },
+      { name: "projectId", description: "Filter to a specific project", required: false },
+      { name: "fromDate", description: "Start date for billable period (ISO format)", required: false },
+      { name: "toDate", description: "End date for billable period (ISO format)", required: false }
+    ]
+  },
+  {
+    name: "client_update",
+    description: "Draft a client update email with recent activity and deliverable progress",
+    arguments: [
+      { name: "clientId", description: "Client ID", required: true },
+      { name: "topic", description: "Update topic", required: false }
+    ]
+  },
+  {
+    name: "handoff_notes",
+    description: "Generate handoff notes when reassigning work with tasks, decisions, and tribal knowledge",
+    arguments: [
+      { name: "projectId", description: "Project ID being handed off", required: true },
+      { name: "fromUserId", description: "Current assignee user ID", required: true },
+      { name: "toUserId", description: "New assignee user ID", required: false },
+      { name: "scope", description: "Scope of handoff (full, partial)", required: false }
+    ]
+  },
+  {
+    name: "capability_gap",
+    description: "Analyze capability matrix to identify gaps, single points of failure, and training needs",
+    arguments: []
+  },
+  {
+    name: "team_availability",
+    description: "Team calendar overview with availability, upcoming leave, and capacity analysis",
+    arguments: [
+      { name: "weeks", description: "Number of weeks to look ahead (default 2)", required: false }
+    ]
+  }
+];
+var generators = {
+  weekly_status: weekly_status_exports,
+  daily_standup: daily_standup_exports,
+  project_health: project_health_exports,
+  meeting_prep: meeting_prep_exports,
+  compliance_check: compliance_check_exports,
+  resource_plan: resource_plan_exports,
+  risk_assessment: risk_assessment_exports,
+  pipeline_review: pipeline_review_exports,
+  invoice_draft: invoice_draft_exports,
+  client_update: client_update_exports,
+  handoff_notes: handoff_notes_exports,
+  capability_gap: capability_gap_exports,
+  team_availability: team_availability_exports
+};
+async function generatePromptContent(name, args) {
+  const generator = generators[name];
+  if (!generator) {
+    throw new Error(`Unknown prompt: ${name}`);
+  }
+  return generator.generate(args);
+}
+
+// src/auth/api-key.ts
+import { z as z19 } from "zod";
+var apiKeyPayloadSchema = z19.object({
+  orgId: z19.string(),
+  permissions: z19.array(z19.enum(["read", "write", "admin"])),
+  expiresAt: z19.date().optional()
+});
+function isValidApiKeyFormat(key) {
+  return /^amplis_[a-f0-9]{64}$/.test(key);
+}
+async function validateApiKey(apiKey) {
+  const baseUrl = process.env.AMPLIS_API_URL || "https://app.amplis.com.au";
+  try {
+    const response = await fetch(`${baseUrl}/api/mcp/auth/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` }
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return { orgId: data.orgId, permissions: data.permissions.map((p) => p.toLowerCase()), expiresAt: data.expiresAt ? new Date(data.expiresAt) : void 0 };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/context.ts
+var cachedContext = null;
+async function initializeContext() {
+  if (process.env.AMPLIS_ORG_ID) {
+    cachedContext = {
+      orgId: process.env.AMPLIS_ORG_ID,
+      userId: process.env.AMPLIS_USER_ID
+    };
+    return cachedContext;
+  }
+  const creds = loadCredentials();
+  if (!creds) {
+    throw new Error(
+      "No credentials found. Run `amplis login` or set AMPLIS_ORG_ID environment variable."
+    );
+  }
+  if (!creds.apiKey || !isValidApiKeyFormat(creds.apiKey)) {
+    throw new Error(
+      "Invalid API key format in credentials. Run `amplis login` to re-authenticate."
+    );
+  }
+  const payload = await validateApiKey(creds.apiKey);
+  if (!payload) {
+    throw new Error(
+      "API key is invalid, revoked, or expired. Run `amplis login` to re-authenticate."
+    );
+  }
+  if (payload.orgId !== creds.orgId) {
+    throw new Error(
+      "API key org does not match stored credentials. Run `amplis login` to re-authenticate."
+    );
+  }
+  cachedContext = {
+    orgId: payload.orgId,
+    userId: creds.userId
+  };
+  process.env.AMPLIS_ORG_ID = payload.orgId;
+  if (creds.userId) {
+    process.env.AMPLIS_USER_ID = creds.userId;
+  }
+  return cachedContext;
+}
+
+// src/cli/login.ts
+import readline from "readline";
+var DEFAULT_API_URL = "https://app.amplis.com.au";
+function prompt(question, masked = false) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (masked && process.stdin.isTTY) {
+      process.stdout.write(question);
+      let input = "";
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding("utf-8");
+      const onData = (char) => {
+        if (char === "\n" || char === "\r" || char === "") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onData);
+          process.stdout.write("\n");
+          rl.close();
+          resolve(input);
+        } else if (char === "") {
+          process.stdout.write("\n");
+          process.exit(1);
+        } else if (char === "\x7F" || char === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else {
+          input += char;
+          process.stdout.write("*");
+        }
+      };
+      process.stdin.on("data", onData);
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    }
+  });
+}
+async function loginCommand() {
+  console.log("\n  AMPLIS MCP Server \u2014 Authentication\n");
+  console.log(
+    "  Generate an API key in the AMPLIS web app:\n  Settings \u2192 API Keys \u2192 Create New Key\n"
+  );
+  const apiKey = await prompt("  Enter your API key: ", true);
+  if (!apiKey) {
+    console.error("\n  Error: No API key provided.");
+    process.exit(1);
+  }
+  if (!isValidApiKeyFormat(apiKey)) {
+    console.error(
+      "\n  Error: Invalid API key format.\n  Keys should look like: amplis_a1b2c3d4e5f6..."
+    );
+    process.exit(1);
+  }
+  const apiUrl = process.env.AMPLIS_API_URL || DEFAULT_API_URL;
+  console.log("\n  Validating API key...");
+  let response;
+  try {
+    response = await fetch(`${apiUrl}/api/mcp/auth/validate`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+  } catch (err) {
+    console.error(
+      `
+  Error: Could not connect to ${apiUrl}
+  Check your internet connection or set AMPLIS_API_URL.
+`
+    );
+    process.exit(1);
+  }
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    const msg = body.error || `HTTP ${response.status}`;
+    console.error(`
+  Authentication failed: ${msg}
+`);
+    process.exit(1);
+  }
+  const data = await response.json();
+  saveCredentials({
+    apiKey,
+    orgId: data.orgId,
+    orgName: data.orgName,
+    userId: data.userId,
+    permissions: data.permissions
+  });
+  console.log("\n  Authenticated successfully!\n");
+  console.log(`  Organization : ${data.orgName}`);
+  console.log(`  Permissions  : ${data.permissions.join(", ")}`);
+  console.log(`  Key prefix   : ${apiKey.substring(0, 16)}...`);
+  console.log("\n  Credentials saved to ~/.amplis/credentials.json\n");
+}
+
+// src/cli/browser-login.ts
+import http from "http";
+import { URL } from "url";
+import crypto from "crypto";
+import open from "open";
+var DEFAULT_API_URL2 = "https://app.amplis.com.au";
+var CALLBACK_PORT = 19284;
+var TIMEOUT_MS = 12e4;
+async function browserLoginCommand() {
+  console.log("\n  \u{1F510} AMPLIS MCP Server \u2014 Browser Authentication\n");
+  const apiUrl = process.env.AMPLIS_API_URL || DEFAULT_API_URL2;
+  const state = crypto.randomBytes(32).toString("hex");
+  const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
+  const authPromise = new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url || "/", `http://localhost:${CALLBACK_PORT}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const error2 = url.searchParams.get("error");
+        if (error2) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <html><body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1 style="color: #dc2626;">\u274C Authentication Failed</h1>
+              <p>${error2}</p>
+              <p>You can close this window.</p>
+            </body></html>
+          `);
+          server.close();
+          reject(new Error(error2));
+          return;
+        }
+        if (returnedState !== state) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <html><body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1 style="color: #dc2626;">\u274C Invalid State</h1>
+              <p>Security validation failed. Please try again.</p>
+              <p>You can close this window.</p>
+            </body></html>
+          `);
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <html><body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1 style="color: #dc2626;">\u274C Missing Code</h1>
+              <p>No authorization code received.</p>
+              <p>You can close this window.</p>
+            </body></html>
+          `);
+          server.close();
+          reject(new Error("Missing authorization code"));
+          return;
+        }
+        try {
+          const exchangeResponse = await fetch(`${apiUrl}/api/mcp/auth/exchange`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code, state })
+          });
+          if (!exchangeResponse.ok) {
+            const errorBody = await exchangeResponse.json().catch(() => ({}));
+            throw new Error(errorBody.error || `HTTP ${exchangeResponse.status}`);
+          }
+          const result = await exchangeResponse.json();
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html><body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1 style="color: #16a34a;">\u2705 Authentication Successful!</h1>
+              <p>Logged in to <strong>${result.orgName}</strong></p>
+              <p>You can close this window and return to your terminal.</p>
+              <script>setTimeout(() => window.close(), 3000);</script>
+            </body></html>
+          `);
+          server.close();
+          resolve(result);
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end(`
+            <html><body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1 style="color: #dc2626;">\u274C Exchange Failed</h1>
+              <p>${err instanceof Error ? err.message : "Unknown error"}</p>
+              <p>You can close this window.</p>
+            </body></html>
+          `);
+          server.close();
+          reject(err);
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1", () => {
+      console.log(`  \u{1F4E1} Callback server listening on port ${CALLBACK_PORT}`);
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Failed to start callback server: ${err.message}`));
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out. Please try again."));
+    }, TIMEOUT_MS);
+  });
+  const authUrl = new URL(`${apiUrl}/auth/mcp`);
+  authUrl.searchParams.set("callback", callbackUrl);
+  authUrl.searchParams.set("state", state);
+  console.log(`  \u{1F310} Opening browser to authenticate...
+`);
+  console.log(`  If the browser doesn't open, visit:`);
+  console.log(`  ${authUrl.toString()}
+`);
+  try {
+    await open(authUrl.toString());
+  } catch {
+  }
+  console.log("  \u23F3 Waiting for authentication...\n");
+  try {
+    const result = await authPromise;
+    saveCredentials({
+      apiKey: result.apiKey,
+      orgId: result.orgId,
+      orgName: result.orgName,
+      userId: result.userId,
+      permissions: result.permissions
+    });
+    console.log("  \u2705 Authentication successful!\n");
+    console.log(`  Organization : ${result.orgName}`);
+    console.log(`  Permissions  : ${result.permissions.join(", ")}`);
+    console.log(`  Key prefix   : ${result.apiKey.substring(0, 16)}...`);
+    console.log("\n  Credentials saved to ~/.amplis/credentials.json\n");
+  } catch (err) {
+    console.error(`
+  \u274C Authentication failed: ${err instanceof Error ? err.message : "Unknown error"}
+`);
+    process.exit(1);
+  }
+}
+
+// src/cli/logout.ts
+async function logoutCommand() {
+  const removed = clearCredentials();
+  if (removed) {
+    console.log("\n  Credentials removed from", getCredentialsPath());
+    console.log("  You are now logged out.\n");
+  } else {
+    console.log("\n  No credentials found \u2014 already logged out.\n");
+  }
+}
+
+// src/cli/status.ts
+async function statusCommand() {
+  console.log("\n  AMPLIS MCP Server \u2014 Status\n");
+  const envOrgId = process.env.AMPLIS_ORG_ID;
+  if (envOrgId) {
+    console.log("  Auth source  : Environment variables");
+    console.log(`  Org ID       : ${envOrgId}`);
+    console.log(`  User ID      : ${process.env.AMPLIS_USER_ID || "(not set)"}`);
+    console.log("");
+    return;
+  }
+  const creds = loadCredentials();
+  if (!creds) {
+    console.log("  Status       : Not authenticated");
+    console.log(`  Config file  : ${getCredentialsPath()} (not found)`);
+    console.log("\n  Run `amplis login` to authenticate.\n");
+    return;
+  }
+  const maskedKey = creds.apiKey ? `${creds.apiKey.substring(0, 16)}...` : "(unknown)";
+  console.log("  Auth source  : ~/.amplis/credentials.json");
+  console.log(`  Organization : ${creds.orgName || creds.orgId}`);
+  console.log(`  Org ID       : ${creds.orgId}`);
+  console.log(`  API key      : ${maskedKey}`);
+  console.log(
+    `  Permissions  : ${creds.permissions?.join(", ") || "(unknown)"}`
+  );
+  console.log("");
+}
+
+// src/cli/index.ts
+var HELP = `
+  AMPLIS MCP Server
+
+  Usage:
+    amplis [command]
+
+  Commands:
+    serve     Start the MCP server (default)
+    login     Authenticate via browser (recommended)
+    login-key Authenticate with API key (manual)
+    logout    Remove stored credentials
+    status    Show current authentication status
+    help      Show this help message
+
+  Environment Variables:
+    AMPLIS_ORG_ID     Override org ID (skips credentials file)
+    AMPLIS_USER_ID    Override user ID
+    AMPLIS_API_URL    API base URL (default: https://app.amplis.com.au)
+`;
+function parseCLICommand(argv) {
+  const cmd = argv[2]?.toLowerCase();
+  switch (cmd) {
+    case "login":
+      return "login";
+    case "login-key":
+      return "login-key";
+    case "logout":
+      return "logout";
+    case "status":
+      return "status";
+    case "help":
+    case "--help":
+    case "-h":
+      return "help";
+    default:
+      return "serve";
+  }
+}
+async function runCLI(command2) {
+  switch (command2) {
+    case "login":
+      await browserLoginCommand();
+      return true;
+    case "login-key":
+      await loginCommand();
+      return true;
+    case "logout":
+      await logoutCommand();
+      return true;
+    case "status":
+      await statusCommand();
+      return true;
+    case "help":
+      console.log(HELP);
+      return true;
+    case "serve":
+      return false;
+  }
+}
+
+// src/index.ts
+var command = parseCLICommand(process.argv);
+if (command !== "serve") {
+  runCLI(command).then(() => process.exit(0)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+} else {
+  const server = new Server(
+    {
+      name: "amplis-mcp-server",
+      version: "0.2.0"
+    },
+    {
+      capabilities: {
+        resources: { listChanged: true },
+        tools: {},
+        prompts: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources };
+  });
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+    return { resourceTemplates: resourceTemplates19 };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    return handleReadResource(request.params.uri);
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: tools18 };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    return handleToolCall18(request.params.name, request.params.arguments);
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return { prompts };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const prompt2 = prompts.find((p) => p.name === name);
+    if (!prompt2) {
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    const content = await generatePromptContent(name, args ?? {});
+    return {
+      description: prompt2.description,
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text: content }
+        }
+      ]
+    };
+  });
+  async function main() {
+    try {
+      const ctx = await initializeContext();
+      console.error(`AMPLIS MCP Server: authenticated for org ${ctx.orgId}`);
+    } catch (err) {
+      console.error("Startup authentication failed:", err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("AMPLIS MCP Server running on stdio");
+  }
+  main().catch((error2) => {
+    console.error("Fatal error:", error2);
+    process.exit(1);
+  });
+}