@thinkingai/ae-cli 6.0.18 → 6.0.20

package/dist/{te-analysis-VAR4KUOK.js → te-analysis-HJ22TUAA.js}

@@ -210,13 +210,30 @@ var updateAlert = createMcpCommand({
   })
 });
 
+// src/commands/te-analysis/meta/delete-alert.ts
+var deleteAlert = createMcpCommand({
+  command: "+delete_alert",
+  description: "Delete an alert by alertId",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "alert_id", type: "number", required: true, desc: "Alert ID to delete" }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    alertId: ctx.num("alert_id")
+  })
+});
+
 // src/commands/te-analysis/meta/index.ts
 var commands = [
   getAlertDefinitionSchema,
   listAlerts,
   getAlert,
   createAlert,
-  updateAlert
+  updateAlert,
+  deleteAlert
 ];
 var meta_default = commands;
 
@@ -226,8 +243,8 @@ var listReports = createMcpCommand({
   description: "List report metadata accessible to the current user in the project. Supports keyword filtering and returns paginated report summaries with selectable fields.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
-    { name: "query", type: "string", required: false, desc: "Optional keyword filter. Performs fuzzy matching against report names, descriptions, and AI remarks; if omitted, all accessible reports are returned.", alias: "q" },
-    { name: "fields", type: "json", required: false, desc: "Optional fields to return. Supported fields: reportId, reportName, reportDesc, reportModel, aiRemark.", alias: "f" },
+    { name: "query", type: "string", required: false, desc: "Optional keyword filter. Performs fuzzy matching against reportName, reportDesc, and remark; if omitted, all accessible reports are returned.", alias: "q" },
+    { name: "fields", type: "json", required: false, desc: "Optional fields to return. Supported fields: reportId, reportName, reportDesc, remark, reportModel. Default fields when omitted: reportId, reportName, reportDesc, remark, reportModel.", alias: "f" },
     { name: "limit", type: "number", required: false, desc: "Optional page size. Default: 20, maximum: 10000.", alias: "l" },
     { name: "offset", type: "number", required: false, desc: "Optional page offset. Default: 0.", alias: "o" }
   ],
@@ -259,18 +276,19 @@ var getReportDefinition = createMcpCommand({
 // src/commands/te-analysis/report/query-report-data.ts
 var queryReportData = createMcpCommand({
   command: "+query_report_data",
-  description: "Query analysis data for one or more reports. Supports extra filters, group-by settings, and time range overrides. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Query analysis data for one or more reports. Supports extra filters, group-by settings, and time range overrides. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "report_ids", type: "json", required: true, desc: "List of report IDs" },
     { name: "filters", type: "json", required: false, desc: "Optional filter JSON. See +get_filter_schema for the structure." },
     { name: "group_by", type: "json", required: false, desc: "Optional group-by JSON array. See +get_groupby_schema for the structure." },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true" },
     { name: "start_date", type: "string", required: false, desc: "Optional start date in yyyy-MM-dd format" },
     { name: "end_date", type: "string", required: false, desc: "Optional end date in yyyy-MM-dd format" },
     { name: "time_granularity", type: "string", required: false, desc: "Optional time granularity used to override the report default. Supported values: minute, minute5, minute10, hour, day, week, month, quarter, year, total." },
     { name: "timeout_minutes", type: "number", required: false, desc: "Query timeout in minutes. If omitted, 30 minutes is used." },
+    { name: "sql_params", type: "json", required: false, desc: `Optional override for a SQL-model report's dynamic parameters (the \${...} placeholders; get each param's paramName/paramType/current shape via +get_report_definition). JSON array matched by paramName. Value fields by paramType: Selector/Variable use paramExpress, e.g. [{"paramName":"selector1","paramExpress":"<value>"}]; Text needs a quota operator + paramExpress (all 13 quota codes, e.g. [{"paramName":"text1","quota":"C00","paramExpress":["<value>"]}]); Number needs quota + paramExpress (numeric ops only); 13 codes incl. C00=IN, C06=BETWEEN/range, C060=BETWEEN by date, C300=CONTAIN, C04=no filter, C05=IS NULL (see the ae-analysis query_report_data reference for the full table); Time needs a quota operator + startTime/endTime (C020 <=, C030 >=, C06/C060 between, C04/C05 has/no value), NOT recentDay; PartDate is a date range (startTime+endTime). Variable has no quota; override paramExpress (custom-type values include their own quotes). Only listed params are overridden; omitted params keep the report's saved defaults. Ignored for non-SQL reports.` },
     ...clusterQueryFlags("Optional cluster query scope. Supported values: GLOBAL, SLAVE. Omit to query the current self cluster.")
   ],
   risk: "read",
@@ -279,12 +297,13 @@ var queryReportData = createMcpCommand({
     reportIds: ctx.json("report_ids"),
     filters: optionalJsonString(ctx, "filters"),
     groupBy: optionalJsonString(ctx, "group_by"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     useCache: optionalBoolean(ctx, "use_cache"),
     startDate: optionalString(ctx, "start_date"),
     endDate: optionalString(ctx, "end_date"),
     timeGranularity: optionalString(ctx, "time_granularity"),
     timeoutMinutes: optionalNumber(ctx, "timeout_minutes"),
+    sqlParams: optionalJsonString(ctx, "sql_params"),
     ...optionalClusterQueryArgs(ctx)
   })
 });
@@ -316,23 +335,66 @@ var createReport = createMcpCommand({
   })
 });
 
+// src/commands/te-analysis/report/delete-report.ts
+var deleteReport = createMcpCommand({
+  command: "+delete_report",
+  description: "Delete a report by reportId",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "report_id", type: "number", required: true, desc: "Report ID to delete" }
+  ],
+  risk: "write",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    reportId: ctx.num("report_id")
+  })
+});
+
+// src/commands/te-analysis/report/update-report.ts
+var updateReport = createMcpCommand({
+  command: "+update_report",
+  description: "Update an existing report. Supports updating name, description, and QP. At least one of report_name, report_desc, or qp must be provided. When updating qp, also provide report_model. First call +get_report_definition to retrieve the current version number.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "report_id", type: "number", required: true, desc: "Report ID to update" },
+    { name: "version", type: "number", required: true, desc: "Current report version number. Retrieve via +get_report_definition." },
+    { name: "report_name", type: "string", required: false, desc: "New report name. Omit to keep existing." },
+    { name: "report_desc", type: "string", required: false, desc: "New report description. Omit to keep existing." },
+    { name: "qp", type: "string", required: false, desc: "New QP JSON string. Omit to keep existing. When provided, also supply report_model." },
+    { name: "report_model", type: "number", required: false, desc: "Analysis model type integer (e.g. 1=event, 2=retention). Required when qp is provided." }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    reportId: ctx.num("report_id"),
+    version: ctx.num("version"),
+    reportName: optionalString(ctx, "report_name"),
+    reportDesc: optionalString(ctx, "report_desc"),
+    qp: optionalString(ctx, "qp"),
+    reportModel: optionalNumber(ctx, "report_model")
+  })
+});
+
 // src/commands/te-analysis/report/index.ts
 var commands2 = [
   listReports,
   getReportDefinition,
   queryReportData,
-  createReport
+  createReport,
+  deleteReport,
+  updateReport
 ];
 var report_default = commands2;
 
 // src/commands/te-analysis/dashboard/list-dashboards.ts
 var listDashboards = createMcpCommand({
   command: "+list_dashboards",
-  description: "List dashboard metadata accessible to the current user in the project. Supports keyword filtering and returns paginated dashboard summaries with selectable fields.",
+  description: "List dashboard metadata accessible to the current user in the project. Supports keyword filtering and returns paginated dashboard summaries. Default returned fields: dashboardId, dashboardName, remark. Dashboard metadata exposes remark but no separate desc field.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
-    { name: "query", type: "string", required: false, desc: "Optional keyword filter. Performs fuzzy matching against dashboard names and AI remarks; if omitted, all accessible dashboards are returned.", alias: "q" },
-    { name: "fields", type: "json", required: false, desc: "Optional fields to return. Supported fields: dashboardId, dashboardName, aiRemark.", alias: "f" },
+    { name: "query", type: "string", required: false, desc: "Optional keyword filter. Performs fuzzy matching against dashboard names and remarks; if omitted, all accessible dashboards are returned.", alias: "q" },
+    { name: "fields", type: "json", required: false, desc: "Optional fields to return. Supported fields: dashboardId, dashboardName, remark. Default fields when omitted: dashboardId, dashboardName, remark.", alias: "f" },
     { name: "limit", type: "number", required: false, desc: "Optional page size. Default: 20, maximum: 10000.", alias: "l" },
     { name: "offset", type: "number", required: false, desc: "Optional page offset. Default: 0.", alias: "o" }
   ],
@@ -387,13 +449,13 @@ var getBiPanelDetail = createMcpCommand({
 // src/commands/te-analysis/dashboard/query-bi-panel-data.ts
 var queryBiPanelData = createMcpCommand({
   command: "+query_bi_panel_data",
-  description: "Query released BI panel data. Use result_type=charts for page chart data as columns and rows, or result_type=summary for summary markdown and blocks. Call get_bi_panel_detail first to obtain pageKey, chartIds, columns, and control schemas. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Query released BI panel data. Use result_type=charts for page chart data as columns and rows, or result_type=summary for summary markdown and blocks. Call get_bi_panel_detail first to obtain pageKey, chartIds, columns, and control schemas. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "panel_id", type: "number", required: true, desc: "BI panel ID returned by +list_bi_panels" },
     { name: "page_key", type: "string", required: true, desc: "Page key returned by +get_bi_panel_detail" },
     { name: "result_type", type: "string", required: true, desc: "Result type. Supported values: charts, summary." },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "chart_ids", type: "json", required: false, desc: "Optional chart IDs when result_type=charts. If omitted, all queryable charts on the page are queried." },
     { name: "parameter_controls", type: "json", required: false, desc: "Optional dashboard-level parameter control overrides. Each item must have controlId and one scalar value." },
     { name: "permission_controls", type: "json", required: false, desc: "Optional dashboard-level permission control values. Each item must have controlId and value. value may be one scalar or an array; allowedValues are hints, not an MCP-side whitelist." },
@@ -412,7 +474,7 @@ var queryBiPanelData = createMcpCommand({
     panelId: ctx.num("panel_id"),
     pageKey: ctx.str("page_key"),
     resultType: ctx.str("result_type"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     chartIds: optionalJson(ctx, "chart_ids"),
     parameterControls: optionalJson(ctx, "parameter_controls"),
     permissionControls: optionalJson(ctx, "permission_controls"),
@@ -445,7 +507,7 @@ var queryDashboardDetail = createMcpCommand({
 // src/commands/te-analysis/dashboard/query-dashboard-report-data.ts
 var queryDashboardReportData = createMcpCommand({
   command: "+query_dashboard_report_data",
-  description: "Query analysis data for one or more reports in a dashboard. Supports additional filters and time range overrides. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Query analysis data for one or more reports in a dashboard. Supports additional filters and time range overrides. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "dashboard_id", type: "number", required: true, desc: "Dashboard ID", alias: "d" },
@@ -455,7 +517,7 @@ var queryDashboardReportData = createMcpCommand({
     { name: "time_granularity", type: "string", required: false, desc: "Optional time granularity used to override the report default. Supported values: minute, minute5, minute10, hour, day, week, month, quarter, year, total." },
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true" },
     { name: "report_ids", type: "json", required: false, desc: "Optional report IDs JSON array" },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "timeout_minutes", type: "number", required: false, desc: "Query timeout in minutes. If omitted, 30 minutes is used." },
     ...clusterQueryFlags("Optional cluster query scope. Supported values: GLOBAL, SLAVE. Omit to follow dashboard configuration.")
   ],
@@ -469,7 +531,7 @@ var queryDashboardReportData = createMcpCommand({
     timeGranularity: optionalString(ctx, "time_granularity"),
     useCache: optionalBoolean(ctx, "use_cache"),
     reportIds: optionalJson(ctx, "report_ids"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     timeoutMinutes: optionalNumber(ctx, "timeout_minutes"),
     ...optionalClusterQueryArgs(ctx)
   })
@@ -641,6 +703,101 @@ var createSpace = createMcpCommand({
   })
 });
 
+// src/commands/te-analysis/dashboard/delete-dashboard.ts
+var deleteDashboard = createMcpCommand({
+  command: "+delete_dashboard",
+  description: "Delete a dashboard by dashboardId",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "dashboard_id", type: "number", required: true, desc: "Dashboard ID to delete" }
+  ],
+  risk: "write",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    dashboardId: ctx.num("dashboard_id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/copy-dashboard.ts
+var copyDashboard = createMcpCommand({
+  command: "+copy_dashboard",
+  description: "Copy a dashboard to a new dashboard. Optionally copies its associated reports. To place the copy in a space or folder, provide to_space_id or to_folder_id.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "dashboard_id", type: "number", required: true, desc: "Source dashboard ID to copy" },
+    { name: "dashboard_name", type: "string", required: true, desc: "Name for the new copied dashboard" },
+    { name: "report_copy", type: "boolean", required: false, desc: "Whether to also copy the associated reports. Defaults to false." },
+    { name: "to_space_id", type: "number", required: false, desc: "Target space ID for the copied dashboard. Omit to use the default location." },
+    { name: "to_folder_id", type: "number", required: false, desc: "Target folder ID inside the target space. Omit to place directly in the space root." }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    dashboardId: ctx.num("dashboard_id"),
+    dashboardName: ctx.str("dashboard_name"),
+    reportCopy: optionalBoolean(ctx, "report_copy"),
+    toSpaceId: optionalNumber(ctx, "to_space_id"),
+    toFolderId: optionalNumber(ctx, "to_folder_id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/move-dashboard.ts
+var moveDashboard = createMcpCommand({
+  command: "+move_dashboard",
+  description: "Move a dashboard to a different space or folder. Provide to_space_id to move to a space root, or both to_space_id and to_folder_id to move into a folder within that space.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "dashboard_id", type: "number", required: true, desc: "Dashboard ID to move" },
+    { name: "to_space_id", type: "number", required: true, desc: "Target space ID to move the dashboard into" },
+    { name: "to_folder_id", type: "number", required: false, desc: "Target folder ID within the target space. Omit to place at the space root." },
+    { name: "from_space_id", type: "number", required: false, desc: "Source space ID the dashboard is currently in. Omit if unknown." },
+    { name: "from_folder_id", type: "number", required: false, desc: "Source folder ID the dashboard is currently in. Omit if unknown." }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    dashboardId: ctx.num("dashboard_id"),
+    toSpaceId: ctx.num("to_space_id"),
+    toFolderId: optionalNumber(ctx, "to_folder_id"),
+    fromSpaceId: optionalNumber(ctx, "from_space_id"),
+    fromFolderId: optionalNumber(ctx, "from_folder_id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/list-spaces.ts
+var listSpaces = createMcpCommand({
+  command: "+list_spaces",
+  description: "List spaces and folders accessible to the current user in the project as a recursive tree. Use to resolve spaceId for create_dashboard / copy_dashboard, and toSpaceId / toFolderId / fromSpaceId / fromFolderId for move_dashboard and copy_dashboard.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" }
+  ],
+  risk: "read",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/freeze-dashboards.ts
+var freezeDashboards = createMcpCommand({
+  command: "+freeze_dashboards",
+  description: "Freeze or unfreeze one or more dashboards. freeze=true freezes and takes scheduled jobs offline; freeze=false unfreezes and brings scheduled jobs back online.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "dashboard_ids", type: "json", required: true, desc: "List of dashboard IDs to freeze or unfreeze" },
+    { name: "freeze", type: "boolean", required: true, desc: "true to freeze, false to unfreeze" }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    dashboardIds: ctx.json("dashboard_ids"),
+    freeze: ctx.bool("freeze")
+  })
+});
+
 // src/commands/te-analysis/dashboard/index.ts
 var commands3 = [
   listDashboards,
@@ -651,23 +808,28 @@ var commands3 = [
   queryDashboardReportData,
   createDashboard,
   updateDashboard,
+  deleteDashboard,
+  copyDashboard,
+  moveDashboard,
   createOrUpdateDashboardNote,
   listPublicAccessLinks,
   createPublicAccessLink,
   updatePublicAccessLink,
-  createSpace
+  createSpace,
+  listSpaces,
+  freezeDashboards
 ];
 var dashboard_default = commands3;
 
 // src/commands/te-analysis/model/query-adhoc.ts
 var queryAdhoc = createMcpCommand({
   command: "+query_adhoc",
-  description: "Run ad hoc analysis with an already-built qp. For event, retention, funnel, and prop_analysis, call the matching +build_*_analysis_qp command first and pass its qp; do not handcraft qp or call get_analysis_query_schema/list_events/list_properties/list_metrics/get_metric before the builder. For distribution, attribution, heat_map, interval, path, rank_list, and sql, use the legacy schema/metadata path. Supports fields/limit/offset pagination. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Run ad hoc analysis with an already-built qp. For event, retention, funnel, and prop_analysis, call the matching +build_*_analysis_qp command first and pass its qp; do not handcraft qp or call get_analysis_query_schema/list_events/list_properties/list_metrics/get_metric before the builder. For distribution, attribution, heat_map, interval, path, rank_list, and sql, use the legacy schema/metadata path. Supports fields/limit/offset pagination. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "model_type", type: "string", required: true, desc: "Model type. Supported values: event, retention, funnel, distribution, attribution, heat_map, interval, path, rank_list, prop_analysis, sql." },
     { name: "qp", type: "json", required: true, desc: "Query parameter JSON. For event/retention/funnel/prop_analysis, pass qp returned by the matching +build_*_analysis_qp command. Use +get_analysis_query_schema only for non-builder/manual model types." },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use result cache. Default: true" },
     { name: "zone_offset", type: "number", required: false, desc: "Time zone offset in hours. For example, UTC+8 is 8 and UTC-5 is -5" },
     { name: "is_sort_by_columns", type: "boolean", required: false, desc: "Whether to sort query results by columns. Default: false" },
@@ -690,7 +852,7 @@ var queryAdhoc = createMcpCommand({
     projectId: ctx.num("project_id"),
     modelType: ctx.str("model_type"),
     qp: requiredJsonString(ctx, "qp"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     useCache: optionalBoolean(ctx, "use_cache"),
     zoneOffset: optionalNumber(ctx, "zone_offset"),
     isSortByColumns: optionalBoolean(ctx, "is_sort_by_columns"),
@@ -706,7 +868,7 @@ var queryAdhoc = createMcpCommand({
 // src/commands/te-analysis/model/cancel-query.ts
 var cancelQuery = createMcpCommand({
   command: "+cancel_query",
-  description: "Cancel a running MCP query by request ID. Use this when a previous query is no longer needed, the caller or agent timed out before the query returned, the request returns fetch failed, hits an HTTP timeout, or the user asks to stop waiting. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running; call +cancel_query --request_id <same value> with the preset requestId to release it. For proactive cancellation, pass requestId to the query tool before starting it, then call cancel_query with the same value if you stop waiting. The auto-generated requestId is not available when the HTTP request fails before a response.",
+  description: "Cancel a running MCP query by request ID. Use this when a previous query is no longer needed, the caller or agent timed out before the query returned, the request returns fetch failed, hits an HTTP timeout, or the user asks to stop waiting. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running; call +cancel_query --request_id <same value> with the requestId supplied before starting the query. For proactive cancellation, generate and pass requestId to the query tool before starting it, then call cancel_query with the same value if you stop waiting.",
   flags: [
     { name: "request_id", type: "string", required: true, desc: "Request ID returned by a query tool in metadata.requestId, or the requestId supplied before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef." },
     { name: "reason", type: "string", required: false, desc: "Optional cancellation reason. Default: MCP_CANCEL_QUERY_TOOL." }
@@ -803,7 +965,7 @@ var buildPropAnalysisQp = createMcpCommand({
 // src/commands/te-analysis/model/drilldown-users.ts
 var drilldownUsers = createMcpCommand({
   command: "+drilldown_users",
-  description: "Drill down to the user list for a specific data point in an existing analysis result. Use only after query_adhoc, query_report_data, or query_dashboard_report_data, and keep qp consistent with the source analysis. Supports pagination with limit/offset. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Drill down to the user list for a specific data point in an existing analysis result. Use only after query_adhoc, query_report_data, or query_dashboard_report_data, and keep qp consistent with the source analysis. Supports pagination with limit/offset. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "model_type", type: "string", required: true, desc: "Model type used in the source analysis. Supported values: event, retention, funnel, distribution, attribution, heat_map, interval, path, rank_list, prop_analysis, sql." },
@@ -825,7 +987,7 @@ var drilldownUsers = createMcpCommand({
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true" },
     { name: "limit", type: "number", required: false, desc: "Optional limit. Default: 1000, maximum: 10000." },
     { name: "offset", type: "number", required: false, desc: "Optional offset. Default: 0." },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "timeout_minutes", type: "number", required: false, desc: "Query timeout in minutes. If omitted, 30 minutes is used." }
   ],
   risk: "read",
@@ -853,7 +1015,7 @@ var drilldownUsers = createMcpCommand({
     useCache: optionalBoolean(ctx, "use_cache"),
     limit: optionalNumber(ctx, "limit") ?? DEFAULT_QUERY_LIMIT,
     offset: optionalNumber(ctx, "offset"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     timeoutMinutes: optionalNumber(ctx, "timeout_minutes")
   })
 });
@@ -861,7 +1023,7 @@ var drilldownUsers = createMcpCommand({
 // src/commands/te-analysis/model/drilldown-user-events.ts
 var drilldownUserEvents = createMcpCommand({
   command: "+drilldown_user_events",
-  description: "Drill down to detailed event sequences for a specific user on specific dates. Use the result of drilldown_users and keep event names and dates consistent with the source analysis. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Drill down to detailed event sequences for a specific user on specific dates. Use the result of drilldown_users and keep event names and dates consistent with the source analysis. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "user_id", type: "string", required: true, desc: "User ID from drilldown_users" },
@@ -881,7 +1043,7 @@ var drilldownUserEvents = createMcpCommand({
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true" },
     { name: "page_num", type: "number", required: false, desc: "Start page number. Default: 1" },
     { name: "page_size", type: "number", required: false, desc: "Page size. Default: 1000, maximum: 10000." },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "timeout_minutes", type: "number", required: false, desc: "Query timeout in minutes. If omitted, 30 minutes is used." }
   ],
   risk: "read",
@@ -907,7 +1069,7 @@ var drilldownUserEvents = createMcpCommand({
     useCache: optionalBoolean(ctx, "use_cache"),
     pageNum: optionalNumber(ctx, "page_num"),
     pageSize: optionalNumber(ctx, "page_size") ?? DEFAULT_QUERY_LIMIT,
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     timeoutMinutes: optionalNumber(ctx, "timeout_minutes")
   })
 });
@@ -992,20 +1154,130 @@ var loadFilters = createMcpCommand({
 // src/commands/te-analysis/model/get-table-columns.ts
 var getTableColumns = createMcpCommand({
   command: "+get_table_columns",
-  description: "Query the field list of a project table. Returns column names and types for the specified catalog, schema, and table so the table structure can be understood before SQL analysis.",
+  description: "Query the field list of a project table. Returns column names and types for a tableRef so the table structure can be understood before SQL analysis.",
   flags: [
     { name: "project_id", type: "number", required: true, alias: "p", desc: "Project ID" },
-    { name: "catalog", type: "string", required: true, desc: "Catalog name. Default: hive" },
-    { name: "schema", type: "string", required: true, desc: "Schema name. Default: ta" },
-    { name: "table", type: "string", required: true, desc: "Table name" }
+    { name: "table_ref", type: "string", required: true, desc: "Table reference. Supports hive.schema.table, schema.table, or table. If only table is provided, the backend resolves it against project available tables and fails on ambiguity." }
   ],
   risk: "read",
   mcpService: "te_analysis_extend",
   buildArgs: (ctx) => ({
     projectId: ctx.num("project_id"),
-    catalog: ctx.str("catalog"),
-    schema: ctx.str("schema"),
-    table: ctx.str("table")
+    tableRef: ctx.str("table_ref")
+  })
+});
+
+// src/commands/te-analysis/model/build-interval-analysis-qp.ts
+var buildIntervalAnalysisQp = createMcpCommand({
+  command: "+build_interval_analysis_qp",
+  description: "Build a validated interval-analysis QP from structured interval intent. Interval analysis measures the time elapsed between an initial event and a return event per user. Call before query_adhoc. This command only builds qp and does not execute query_adhoc.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "time_range", type: "json", required: true, desc: "Required time range JSON for interval analysis." },
+    { name: "interval", type: "json", required: true, desc: "Interval analysis intent JSON. Required fields: initialEvent, returnEvent, window (value+unit). Optional: relationEventPropertyName, groups, filters, initialFilters, returnFilters, initialFilterRelation, returnFilterRelation." },
+    { name: "relation", type: "string", required: false, desc: "Filter relation for top-level interval filters. Supported values: and, or. Default: and." },
+    { name: "time_particle_size", type: "string", required: false, desc: "Time granularity. Allowed values: day, week, month. Defaults to day when omitted." }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    timeRange: ctx.json("time_range"),
+    interval: ctx.json("interval"),
+    relation: optionalString(ctx, "relation"),
+    timeParticleSize: optionalString(ctx, "time_particle_size")
+  })
+});
+
+// src/commands/te-analysis/model/build-path-analysis-qp.ts
+var buildPathAnalysisQp = createMcpCommand({
+  command: "+build_path_analysis_qp",
+  description: "Build a validated path-analysis QP from structured path intent. Path analysis visualizes user navigation flows between events within a session. Call before query_adhoc. This command only builds qp and does not execute query_adhoc.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "time_range", type: "json", required: true, desc: "Required time range JSON for path analysis." },
+    { name: "path", type: "json", required: true, desc: "Path analysis intent JSON. Required fields: sourceEvent, eventNames (array), sessionInterval, sessionUnit. Optional: sourceType (0=forward, 1=backward, default 0)." }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    timeRange: ctx.json("time_range"),
+    path: ctx.json("path")
+  })
+});
+
+// src/commands/te-analysis/model/build-attribution-analysis-qp.ts
+var buildAttributionAnalysisQp = createMcpCommand({
+  command: "+build_attribution_analysis_qp",
+  description: "Build a validated attribution-analysis QP from structured attribution intent. Attribution analysis assigns conversion credit to touchpoint events that preceded a target conversion event. Call before query_adhoc. This command only builds qp and does not execute query_adhoc.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "time_range", type: "json", required: true, desc: "Required time range JSON for attribution analysis." },
+    { name: "attribution", type: "json", required: true, desc: "Attribution intent JSON. Required fields: targetEvent, targetAggregation, attributionEvents (array), attributionModel (first/last/linear), window (value+unit). Optional: targetProperty, directConversion, filters, relation." }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    timeRange: ctx.json("time_range"),
+    attribution: ctx.json("attribution")
+  })
+});
+
+// src/commands/te-analysis/model/build-heat-map-analysis-qp.ts
+var buildHeatMapAnalysisQp = createMcpCommand({
+  command: "+build_heat_map_analysis_qp",
+  description: "Build a validated heatmap-analysis QP from structured heatmap intent. Heatmap analysis visualizes user interaction intensity on a 2D coordinate plane (e.g. screen position). Call before query_adhoc. This command only builds qp and does not execute query_adhoc.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "time_range", type: "json", required: true, desc: "Required time range JSON for heatmap analysis." },
+    { name: "heat_map", type: "json", required: true, desc: "Heatmap intent JSON. Required fields: hotEvent, hotAggregation, xProp, yProp. Optional: hotProperty, filters, relation." }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    timeRange: ctx.json("time_range"),
+    heatMap: ctx.json("heat_map")
+  })
+});
+
+// src/commands/te-analysis/model/build-rank-list-analysis-qp.ts
+var buildRankListAnalysisQp = createMcpCommand({
+  command: "+build_rank_list_analysis_qp",
+  description: "Build a validated rank-list-analysis QP from structured rank list intent. Rank list analysis ranks entities (users, items, etc.) by a metric value. Call before query_adhoc. This command only builds qp and does not execute query_adhoc.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "time_range", type: "json", required: true, desc: "Required time range JSON for rank list analysis." },
+    { name: "rank_list", type: "json", required: true, desc: "Rank list intent JSON. Required fields: rankDimension (field), rankEvent, rankAggregation. Optional: rankProperty, rankType (rank/dense_rank/row_rank), orderBy (DESC/ASC), filters, relation." }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    timeRange: ctx.json("time_range"),
+    rankList: ctx.json("rank_list")
+  })
+});
+
+// src/commands/te-analysis/model/build-distribution-analysis-qp.ts
+var buildDistributionAnalysisQp = createMcpCommand({
+  command: "+build_distribution_analysis_qp",
+  description: "Build a validated distribution-analysis QP from structured distribution metrics. Distribution analysis shows how a metric value is distributed across users or events. Call before query_adhoc. This command only builds qp and does not execute query_adhoc.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "time_range", type: "json", required: true, desc: "Required time range JSON for distribution analysis." },
+    { name: "distribution_metrics", type: "json", required: true, desc: "Distribution metrics JSON array. Each item: event, aggregation (A200=count/A201=active-days/A202=active-hours/A103=sum etc.). Optional per item: property, percentile, intervalType, quotaIntervalArr, filters, relation." },
+    { name: "time_particle_size", type: "string", required: false, desc: "Time granularity. Allowed values: day, week, month, total. Defaults to day when omitted." },
+    { name: "groups", type: "json", required: false, desc: "Optional group-by dimensions JSON array." },
+    { name: "filters", type: "json", required: false, desc: "Optional global filters JSON array." },
+    { name: "relation", type: "string", required: false, desc: "Optional filter relation. Supported values: and, or. Default: and." }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    timeRange: ctx.json("time_range"),
+    distributionMetrics: ctx.json("distribution_metrics"),
+    timeParticleSize: optionalString(ctx, "time_particle_size"),
+    groups: optionalJson(ctx, "groups"),
+    filters: optionalJson(ctx, "filters"),
+    relation: optionalString(ctx, "relation")
   })
 });
 
@@ -1015,6 +1287,12 @@ var commands4 = [
   buildRetentionAnalysisQp,
   buildFunnelAnalysisQp,
   buildPropAnalysisQp,
+  buildIntervalAnalysisQp,
+  buildPathAnalysisQp,
+  buildAttributionAnalysisQp,
+  buildHeatMapAnalysisQp,
+  buildRankListAnalysisQp,
+  buildDistributionAnalysisQp,
   queryAdhoc,
   cancelQuery,
   drilldownUsers,
@@ -1028,7 +1306,7 @@ var model_default = commands4;
 // src/commands/te-analysis/entity/query-entity-details.ts
 var queryEntityDetails = createMcpCommand({
   command: "+query_entity_details",
-  description: "Query entity detail data based on an entity ID and cluster definition. Supports display properties, sorting, and result limits. For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Query entity detail data based on an entity ID and cluster definition. Supports display properties, sorting, and result limits. For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "entity_id", type: "number", required: false, desc: "Optional entity ID used in multi-entity scenarios. If omitted, the default user entity is used." },
@@ -1039,7 +1317,7 @@ var queryEntityDetails = createMcpCommand({
     { name: "limit", type: "number", required: false, desc: "Optional result limit. Default: 1000, maximum: 10000" },
     { name: "zone_offset", type: "number", required: false, desc: "Time zone offset. For example, UTC+8 is 8" },
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true" },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "timeout_minutes", type: "number", required: false, desc: "Query timeout in minutes. If omitted, 30 minutes is used." }
   ],
   risk: "read",
@@ -1056,7 +1334,7 @@ var queryEntityDetails = createMcpCommand({
     limit: optionalNumber(ctx, "limit") ?? DEFAULT_QUERY_LIMIT,
     zoneOffset: optionalNumber(ctx, "zone_offset"),
     useCache: optionalBoolean(ctx, "use_cache"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     timeoutMinutes: optionalNumber(ctx, "timeout_minutes")
   })
 });
@@ -1064,7 +1342,7 @@ var queryEntityDetails = createMcpCommand({
 // src/commands/te-analysis/entity/query-event-details.ts
 var queryEventDetails = createMcpCommand({
   command: "+query_event_details",
-  description: "Query event detail data. Supports time range, filters, display properties, sorting, and result limits. Time can be specified via --relative_date_range OR (--start_time AND --end_time). For long-running or cancelable queries, provide requestId before starting. For any query that may exceed the CLI or MCP HTTP timeout, preset requestId so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. If provided, requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup.",
+  description: "Query event detail data. Supports time range, filters, display properties, sorting, and result limits. Time can be specified via --relative_date_range OR (--start_time AND --end_time). For long-running or cancelable queries, requestId is required and must be provided before starting. For any query that may exceed the CLI or MCP HTTP timeout, generate requestId first so you can call +cancel_query --request_id <same value> if you stop waiting or the request returns fetch failed. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Submitted queries return metadata.requestId; pass that value to cancel_query(requestId) when the query is no longer needed. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If requestId is omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID.",
   flags: [
     { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
     { name: "event_name", type: "string", required: true, desc: "Event name" },
@@ -1078,7 +1356,7 @@ var queryEventDetails = createMcpCommand({
     { name: "limit", type: "number", required: false, desc: "Optional result limit. Default: 1000, maximum: 10000" },
     { name: "zone_offset", type: "number", required: false, desc: "Time zone offset. For example, UTC+8 is 8" },
     { name: "use_cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true" },
-    { name: "request_id", type: "string", required: false, desc: "Optional unique request ID used for tracking and cancellation. If provided, it must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. For long-running or cancelable queries, provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. The auto-generated requestId is not available when the HTTP request fails before a response, so preset requestId is required for proactive cleanup. Generated automatically if omitted. The response metadata.requestId can also be passed to cancel_query when the query is no longer needed." },
+    { name: "request_id", type: "string", required: true, desc: "Required unique request ID used for tracking and cancellation. Generate it before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef. Provide this before starting the query so it can be cancelled later with +cancel_query --request_id <same value>, even if the caller stops waiting before the tool returns. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running. requestId is not auto-generated for MCP query tools because the caller must know it before the response for proactive cleanup. If omitted or blank, the backend returns REQUEST_ID_REQUIRED; invalid format returns INVALID_REQUEST_ID. The response metadata.requestId echoes the supplied requestId and can also be passed to cancel_query(requestId) when the query is no longer needed." },
     { name: "timeout_minutes", type: "number", required: false, desc: "Query timeout in minutes. If omitted, 30 minutes is used." }
   ],
   risk: "read",
@@ -1095,7 +1373,7 @@ var queryEventDetails = createMcpCommand({
     limit: optionalNumber(ctx, "limit"),
     zoneOffset: optionalNumber(ctx, "zone_offset"),
     useCache: optionalBoolean(ctx, "use_cache"),
-    requestId: optionalString(ctx, "request_id"),
+    requestId: ctx.str("request_id"),
     timeoutMinutes: optionalNumber(ctx, "timeout_minutes")
   })
 });