gitlab-mcp 1.4.1 → 1.5.1

package/dist/tools/gitlab.js

@@ -1,8 +1,11 @@
+import { Buffer } from "node:buffer";
 import { Kind, parse } from "graphql";
 import { z } from "zod";
 import { GitLabApiError } from "../lib/gitlab-client.js";
+import { applySearchReplace, applyUnifiedDiff, parseSearchReplaceBlocks } from "../lib/patch-helper.js";
 import { bodySchema, displayNameSchema, nullableOptional, optionalBodySchema, optionalDisplayNameSchema, optionalProjectIdSchema, optionalRefLikeSchema, optionalUrlOrPathSchema, projectIdSchema, refLikeSchema, slugSchema } from "../lib/tool-schema.js";
 import { getSessionAuth } from "../lib/auth-context.js";
+import { createDownloadToken } from "../lib/download-token.js";
 import { stripNullsDeep } from "../lib/sanitize.js";
 import { getMergeRequestCodeContext, mergeRequestCodeContextSchema } from "./mr-code-context.js";
 const readCapabilities = ["read"];
@@ -30,6 +33,40 @@ const paginationShape = {
     page: optionalNumber,
     per_page: optionalNumber
 };
+const emojiNameSchema = z.string().min(1);
+const awardEmojiIdSchema = z.string().min(1);
+const workItemTypes = [
+    "issue",
+    "task",
+    "incident",
+    "test_case",
+    "epic",
+    "key_result",
+    "objective",
+    "requirement",
+    "ticket"
+];
+const workItemTypeSchema = z.preprocess((value) => (typeof value === "string" ? value.toLowerCase() : value), z.enum(workItemTypes));
+const optionalWorkItemType = nullableOptional(workItemTypeSchema);
+const workItemIidSchema = z.coerce.number().int().positive();
+const optionalCoercedNumber = nullableOptional(z.coerce.number());
+const optionalCoercedBoolean = nullableOptional(z.coerce.boolean());
+const workItemReferenceSchema = z.object({
+    project_id: projectIdSchema,
+    iid: workItemIidSchema
+});
+const linkedWorkItemReferenceSchema = z.object({
+    project_id: projectIdSchema,
+    iid: workItemIidSchema,
+    link_type: z.enum(["RELATED", "BLOCKED_BY", "BLOCKS"]).optional()
+});
+const customFieldValueSchema = z.object({
+    custom_field_id: z.string().min(1),
+    text_value: optionalString,
+    number_value: optionalCoercedNumber,
+    selected_option_ids: optionalStringArray,
+    date_value: optionalString
+});
 export function registerGitLabTools(server, context) {
     const definitions = getGitLabToolDefinitions();
     const disableGraphqlTools = shouldDisableGraphqlTools(context.env.GITLAB_ALLOWED_PROJECT_IDS, context.env.GITLAB_ALLOW_GRAPHQL_WITH_PROJECT_SCOPE);
@@ -113,6 +150,7 @@ function getGitLabToolDefinitions() {
             capabilities: readCapabilities,
             inputSchema: {
                 search: optionalString,
+                topic: optionalString,
                 search_namespaces: optionalBoolean,
                 membership: optionalBoolean,
                 owned: optionalBoolean,
@@ -154,6 +192,26 @@ function getGitLabToolDefinitions() {
                 default_branch: getOptionalString(args, "default_branch")
             })
         },
+        {
+            name: "gitlab_create_group",
+            title: "Create Group",
+            description: "Create a new GitLab group or subgroup.",
+            capabilities: adminCapabilities,
+            inputSchema: {
+                name: displayNameSchema,
+                path: z.string().min(1),
+                description: optionalString,
+                visibility: z.enum(["private", "internal", "public"]).optional(),
+                parent_id: optionalNumber
+            },
+            handler: async (args, context) => context.gitlab.createGroup({
+                name: getString(args, "name"),
+                path: getString(args, "path"),
+                description: getOptionalString(args, "description"),
+                visibility: getOptionalString(args, "visibility"),
+                parent_id: getOptionalNumber(args, "parent_id")
+            })
+        },
         {
             name: "gitlab_list_project_members",
             title: "List Project Members",
@@ -183,6 +241,7 @@ function getGitLabToolDefinitions() {
                 group_id: z.string(),
                 include_subgroups: optionalBoolean,
                 search: optionalString,
+                topic: optionalString,
                 order_by: z
                     .enum(["name", "path", "created_at", "updated_at", "last_activity_at"])
                     .optional(),
@@ -253,10 +312,62 @@ function getGitLabToolDefinitions() {
                 project_id: optionalProjectIdSchema,
                 search: z.string().min(1),
                 ref: optionalRefLikeSchema,
+                filename: optionalString,
+                path: optionalString,
+                extension: optionalString,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.searchCodeBlobs(resolveProjectId(args, context, true), getString(args, "search"), { query: toQuery(omit(args, ["project_id", "search"])) })
+        },
+        {
+            name: "gitlab_search_code",
+            title: "Search Code",
+            description: "Search code across all projects on the GitLab instance. Requires GitLab code search support.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                search: z.string().min(1),
+                filename: optionalString,
+                path: optionalString,
+                extension: optionalString,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.searchCode(getString(args, "search"), {
+                query: toQuery(omit(args, ["search"]))
+            })
+        },
+        {
+            name: "gitlab_search_project_code",
+            title: "Search Project Code",
+            description: "Search code in a specific project.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                search: z.string().min(1),
+                ref: optionalRefLikeSchema,
+                filename: optionalString,
+                path: optionalString,
+                extension: optionalString,
                 ...paginationShape
             },
             handler: async (args, context) => context.gitlab.searchCodeBlobs(resolveProjectId(args, context, true), getString(args, "search"), { query: toQuery(omit(args, ["project_id", "search"])) })
         },
+        {
+            name: "gitlab_search_group_code",
+            title: "Search Group Code",
+            description: "Search code in a specific group.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                group_id: projectIdSchema,
+                search: z.string().min(1),
+                filename: optionalString,
+                path: optionalString,
+                extension: optionalString,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.searchGroupCodeBlobs(getString(args, "group_id"), getString(args, "search"), {
+                query: toQuery(omit(args, ["group_id", "search"]))
+            })
+        },
         {
             name: "gitlab_get_repository_tree",
             title: "Get Repository Tree",
@@ -284,7 +395,8 @@ function getGitLabToolDefinitions() {
             inputSchema: {
                 project_id: optionalProjectIdSchema,
                 file_path: z.string().min(1),
-                ref: optionalRefLikeSchema
+                ref: optionalRefLikeSchema,
+                decode_base64: optionalBoolean
             },
             handler: async (args, context) => {
                 const projectId = resolveProjectId(args, context, true);
@@ -293,7 +405,37 @@ function getGitLabToolDefinitions() {
                     const project = (await context.gitlab.getProject(projectId));
                     ref = typeof project.default_branch === "string" ? project.default_branch : "main";
                 }
-                return context.gitlab.getFileContents(projectId, getString(args, "file_path"), ref);
+                const result = await context.gitlab.getFileContents(projectId, getString(args, "file_path"), ref);
+                return maybeDecodeRepositoryFileContents(result, getOptionalBoolean(args, "decode_base64"));
+            }
+        },
+        {
+            name: "gitlab_get_file_blame",
+            title: "Get File Blame",
+            description: "Get git blame for a repository file at a given ref. Optional line range must provide both range_start and range_end.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                file_path: z.string().min(1),
+                ref: refLikeSchema,
+                range_start: z.number().int().positive().optional(),
+                range_end: z.number().int().positive().optional()
+            },
+            handler: async (args, context) => {
+                const rangeStart = getOptionalNumber(args, "range_start");
+                const rangeEnd = getOptionalNumber(args, "range_end");
+                if ((rangeStart === undefined) !== (rangeEnd === undefined)) {
+                    throw new Error("range_start and range_end must be provided together");
+                }
+                if (rangeStart !== undefined && rangeEnd !== undefined && rangeStart > rangeEnd) {
+                    throw new Error("range_start must be less than or equal to range_end");
+                }
+                return context.gitlab.getFileBlame(resolveProjectId(args, context, true), getString(args, "file_path"), getString(args, "ref"), {
+                    query: toQuery({
+                        "range[start]": rangeStart,
+                        "range[end]": rangeEnd
+                    })
+                });
             }
         },
         {
@@ -417,6 +559,44 @@ function getGitLabToolDefinitions() {
                 });
             }
         },
+        {
+            name: "gitlab_list_branches",
+            title: "List Branches",
+            description: "List repository branches.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                search: optionalString,
+                regex: optionalString,
+                sort: z.enum(["name_asc", "updated_asc", "updated_desc"]).optional(),
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listBranches(resolveProjectId(args, context, true), {
+                query: toQuery(omit(args, ["project_id"]))
+            })
+        },
+        {
+            name: "gitlab_get_branch",
+            title: "Get Branch",
+            description: "Get details for one repository branch.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                branch: refLikeSchema
+            },
+            handler: async (args, context) => context.gitlab.getBranch(resolveProjectId(args, context, true), getString(args, "branch"))
+        },
+        {
+            name: "gitlab_delete_branch",
+            title: "Delete Branch",
+            description: "Delete a repository branch permanently. Requires branch. Recommended pre-check: gitlab_get_branch.",
+            capabilities: deleteCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                branch: refLikeSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteBranch(resolveProjectId(args, context, true), getString(args, "branch"))
+        },
         {
             name: "gitlab_get_branch_diffs",
             title: "Get Branch Diffs",
@@ -502,6 +682,49 @@ function getGitLabToolDefinitions() {
                 });
             }
         },
+        {
+            name: "gitlab_list_commit_statuses",
+            title: "List Commit Statuses",
+            description: "List statuses for a commit.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                sha: z.string().min(1),
+                ref: optionalRefLikeSchema,
+                stage: optionalString,
+                name: optionalString,
+                pipeline_id: optionalNumber,
+                order_by: z.enum(["id", "pipeline_id"]).optional(),
+                sort: z.enum(["asc", "desc"]).optional(),
+                all: optionalBoolean,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listCommitStatuses(resolveProjectId(args, context, true), getString(args, "sha"), { query: toQuery(omit(args, ["project_id", "sha"])) })
+        },
+        {
+            name: "gitlab_create_commit_status",
+            title: "Create Commit Status",
+            description: "Create or update the status of a commit.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                sha: z.string().min(1),
+                state: z.enum(["pending", "running", "success", "failed", "canceled", "skipped"]),
+                ref: optionalRefLikeSchema,
+                name: optionalString,
+                context: optionalString,
+                target_url: optionalString,
+                description: optionalString,
+                coverage: optionalNumber,
+                pipeline_id: optionalNumber
+            },
+            handler: async (args, context) => {
+                if (getOptionalString(args, "name") && getOptionalString(args, "context")) {
+                    throw new Error("Use either name or context when creating a commit status, not both");
+                }
+                return context.gitlab.createCommitStatus(resolveProjectId(args, context, true), getString(args, "sha"), toQuery(omit(args, ["project_id", "sha"])));
+            }
+        },
         {
             name: "gitlab_list_merge_requests",
             title: "List Merge Requests",
@@ -564,7 +787,8 @@ function getGitLabToolDefinitions() {
                 const projectId = resolveProjectId(args, context, true);
                 const mergeRequestIid = getOptionalString(args, "merge_request_iid");
                 if (mergeRequestIid) {
-                    return context.gitlab.getMergeRequest(projectId, mergeRequestIid);
+                    const mergeRequest = await context.gitlab.getMergeRequest(projectId, mergeRequestIid);
+                    return withMergeRequestSummaries(projectId, mergeRequest, context);
                 }
                 const sourceBranch = getOptionalString(args, "source_branch");
                 if (!sourceBranch) {
@@ -580,9 +804,22 @@ function getGitLabToolDefinitions() {
                 const match = pickMergeRequestForSourceBranch(candidates, sourceBranch, {
                     requireOpened: false
                 });
-                return match;
+                const mergeRequest = await getDetailedMergeRequestFromMatch(projectId, match, context);
+                return withMergeRequestSummaries(projectId, mergeRequest, context);
             }
         },
+        {
+            name: "gitlab_list_merge_request_pipelines",
+            title: "List Merge Request Pipelines",
+            description: "List pipelines associated with a merge request.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listMergeRequestPipelines(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), { query: toQuery(omit(args, ["project_id", "merge_request_iid"])) })
+        },
         {
             name: "gitlab_create_merge_request",
             title: "Create Merge Request",
@@ -739,6 +976,33 @@ function getGitLabToolDefinitions() {
             },
             handler: async (args, context) => context.gitlab.getMergeRequestDiffs(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), { query: toQuery(omit(args, ["project_id", "merge_request_iid"])) })
         },
+        {
+            name: "gitlab_list_merge_request_changed_files",
+            title: "List Merge Request Changed Files",
+            description: "Step 1 for large MR review: return changed file metadata without diff content.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: optionalString,
+                source_branch: optionalRefLikeSchema,
+                excluded_file_patterns: optionalStringArray
+            },
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const mergeRequestIid = await resolveMergeRequestIid(args, context, projectId, {
+                    requireOpened: false
+                });
+                const response = await context.gitlab.getMergeRequestDiffs(projectId, mergeRequestIid);
+                const files = extractMergeRequestChanges(response).map((item) => ({
+                    new_path: item.new_path,
+                    old_path: item.old_path,
+                    new_file: item.new_file,
+                    deleted_file: item.deleted_file,
+                    renamed_file: item.renamed_file
+                }));
+                return filterChangedFiles(files, getOptionalStringArray(args, "excluded_file_patterns"));
+            }
+        },
         {
             name: "gitlab_list_merge_request_diffs",
             title: "List Merge Request Diffs",
@@ -753,6 +1017,67 @@ function getGitLabToolDefinitions() {
             },
             handler: async (args, context) => context.gitlab.listMergeRequestDiffs(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), { query: toQuery(omit(args, ["project_id", "merge_request_iid"])) })
         },
+        {
+            name: "gitlab_get_merge_request_file_diff",
+            title: "Get Merge Request File Diff",
+            description: "Step 2 for large MR review: fetch diffs for specific files from a merge request.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: optionalString,
+                source_branch: optionalRefLikeSchema,
+                file_paths: z.array(z.string().min(1)).min(1),
+                unidiff: optionalBoolean
+            },
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const mergeRequestIid = await resolveMergeRequestIid(args, context, projectId, {
+                    requireOpened: false
+                });
+                const requested = getRequiredStringArray(args, "file_paths");
+                const remaining = new Set(requested);
+                const results = [];
+                let page = 1;
+                const perPage = 20;
+                while (remaining.size > 0) {
+                    const pageItems = extractMergeRequestDiffRecords(await context.gitlab.listMergeRequestDiffs(projectId, mergeRequestIid, {
+                        query: toQuery({
+                            page,
+                            per_page: perPage,
+                            unidiff: getOptionalBoolean(args, "unidiff")
+                        })
+                    }));
+                    if (pageItems.length === 0) {
+                        break;
+                    }
+                    for (const item of pageItems) {
+                        const newPath = typeof item.new_path === "string" ? item.new_path : undefined;
+                        const oldPath = typeof item.old_path === "string" ? item.old_path : undefined;
+                        if ((newPath && remaining.has(newPath)) || (oldPath && remaining.has(oldPath))) {
+                            results.push(item);
+                            if (newPath) {
+                                remaining.delete(newPath);
+                            }
+                            if (oldPath) {
+                                remaining.delete(oldPath);
+                            }
+                        }
+                    }
+                    if (pageItems.length < perPage) {
+                        break;
+                    }
+                    page += 1;
+                }
+                for (const missing of remaining) {
+                    results.push({
+                        file_path: missing,
+                        error: `File not found in merge request diffs: ${missing}`,
+                        hint: "Use gitlab_list_merge_request_changed_files to verify the correct file paths."
+                    });
+                }
+                return results;
+            }
+        },
         {
             name: "gitlab_get_merge_request_code_context",
             title: "Get Merge Request Code Context",
@@ -1150,6 +1475,92 @@ function getGitLabToolDefinitions() {
             },
             handler: async (args, context) => context.gitlab.deleteMergeRequestNote(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), getString(args, "note_id"))
         },
+        {
+            name: "gitlab_list_merge_request_emoji_reactions",
+            title: "List Merge Request Emoji Reactions",
+            description: "List emoji reactions on a merge request.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listMergeRequestEmojiReactions(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), { query: toQuery(omit(args, ["project_id", "merge_request_iid"])) })
+        },
+        {
+            name: "gitlab_list_merge_request_note_emoji_reactions",
+            title: "List MR Note Emoji Reactions",
+            description: "List emoji reactions on a merge request note. Pass discussion_id for discussion replies.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                note_id: z.string().min(1),
+                discussion_id: optionalString,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listMergeRequestNoteEmojiReactions(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), getString(args, "note_id"), { discussion_id: getOptionalString(args, "discussion_id") }, {
+                query: toQuery(omit(args, ["project_id", "merge_request_iid", "note_id", "discussion_id"]))
+            })
+        },
+        {
+            name: "gitlab_create_merge_request_emoji_reaction",
+            title: "Create Merge Request Emoji Reaction",
+            description: "Add an emoji reaction to a merge request, for example thumbsup, rocket, or eyes.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => context.gitlab.createMergeRequestEmojiReaction(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), getString(args, "name"))
+        },
+        {
+            name: "gitlab_delete_merge_request_emoji_reaction",
+            title: "Delete Merge Request Emoji Reaction",
+            description: "Delete an emoji reaction from a merge request permanently. Irreversible for that reaction. Requires merge_request_iid and award_id. Recommended pre-check: gitlab_list_merge_request_emoji_reactions.",
+            capabilities: deleteCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                award_id: awardEmojiIdSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteMergeRequestEmojiReaction(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), getString(args, "award_id"))
+        },
+        {
+            name: "gitlab_create_merge_request_note_emoji_reaction",
+            title: "Create MR Note Emoji Reaction",
+            description: "Add an emoji reaction to a merge request note. Pass discussion_id for discussion replies.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                note_id: z.string().min(1),
+                discussion_id: optionalString,
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => context.gitlab.createMergeRequestNoteEmojiReaction(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), getString(args, "note_id"), {
+                name: getString(args, "name"),
+                discussion_id: getOptionalString(args, "discussion_id")
+            })
+        },
+        {
+            name: "gitlab_delete_merge_request_note_emoji_reaction",
+            title: "Delete MR Note Emoji Reaction",
+            description: "Delete an emoji reaction from a merge request note permanently. Irreversible for that reaction. Requires merge_request_iid, note_id, and award_id. Recommended pre-check: gitlab_list_merge_request_note_emoji_reactions.",
+            capabilities: deleteCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                merge_request_iid: z.string().min(1),
+                note_id: z.string().min(1),
+                discussion_id: optionalString,
+                award_id: awardEmojiIdSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteMergeRequestNoteEmojiReaction(resolveProjectId(args, context, true), getString(args, "merge_request_iid"), getString(args, "note_id"), {
+                award_id: getString(args, "award_id"),
+                discussion_id: getOptionalString(args, "discussion_id")
+            })
+        },
         {
             name: "gitlab_list_issues",
             title: "List Issues",
@@ -1211,6 +1622,71 @@ function getGitLabToolDefinitions() {
                 });
             }
         },
+        {
+            name: "gitlab_list_todos",
+            title: "List Todos",
+            description: "List to-do items for the current authenticated user.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                action: z
+                    .enum([
+                    "assigned",
+                    "mentioned",
+                    "build_failed",
+                    "marked",
+                    "approval_required",
+                    "unmergeable",
+                    "directly_addressed",
+                    "merge_train_removed",
+                    "member_access_requested"
+                ])
+                    .optional(),
+                author_id: optionalNumber,
+                project_id: optionalNumber,
+                group_id: optionalNumber,
+                state: z.enum(["pending", "done"]).optional(),
+                type: z
+                    .enum([
+                    "Issue",
+                    "MergeRequest",
+                    "Commit",
+                    "Epic",
+                    "DesignManagement::Design",
+                    "AlertManagement::Alert",
+                    "Project",
+                    "Namespace",
+                    "Vulnerability",
+                    "WikiPage::Meta"
+                ])
+                    .optional(),
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listTodos({ query: toQuery(args) })
+        },
+        {
+            name: "gitlab_mark_todo_done",
+            title: "Mark Todo Done",
+            description: "Mark one to-do item as done.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                todo_id: z.string().min(1)
+            },
+            handler: async (args, context) => context.gitlab.markTodoDone(getString(args, "todo_id"))
+        },
+        {
+            name: "gitlab_mark_all_todos_done",
+            title: "Mark All Todos Done",
+            description: "Mark all pending to-do items as done for the current authenticated user.",
+            capabilities: writeCapabilities,
+            inputSchema: {},
+            handler: async (_args, context) => {
+                await context.gitlab.markAllTodosDone();
+                return {
+                    status: "success",
+                    message: "All pending to-do items marked as done"
+                };
+            }
+        },
         {
             name: "gitlab_get_issue",
             title: "Get Issue",
@@ -1266,7 +1742,7 @@ function getGitLabToolDefinitions() {
                 confidential: optionalBoolean,
                 assignee_ids: optionalNumberArray,
                 discussion_locked: optionalBoolean,
-                weight: optionalNumber,
+                weight: optionalCoercedNumber,
                 issue_type: z.enum(["issue", "incident", "test_case", "task"]).optional()
             },
             handler: async (args, context) => {
@@ -1280,6 +1756,79 @@ function getGitLabToolDefinitions() {
                 return context.gitlab.updateIssue(resolveProjectId(args, context, true), getString(args, "issue_iid"), payload);
             }
         },
+        {
+            name: "gitlab_update_issue_description_patch",
+            title: "Update Issue Description Patch",
+            description: "Apply a search/replace or unified diff patch to an issue description without sending the full replacement text.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1),
+                patch_type: z.enum(["search_replace", "unified_diff"]),
+                patch: z.string().min(1).max(50_000),
+                dry_run: optionalBoolean,
+                create_note: optionalBoolean,
+                allow_multiple: optionalBoolean
+            },
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const issueIid = getString(args, "issue_iid");
+                const issue = (await context.gitlab.getIssue(projectId, issueIid));
+                const currentDescription = typeof issue.description === "string" ? issue.description : "";
+                const patchType = getString(args, "patch_type");
+                const patch = getString(args, "patch");
+                let result;
+                if (patchType === "search_replace") {
+                    const blocks = parseSearchReplaceBlocks(patch);
+                    if (blocks.length === 0) {
+                        throw new Error("No valid search/replace blocks found. Expected format: <<<<<<< SEARCH\\ntext\\n=======\\nnew text\\n>>>>>>> REPLACE");
+                    }
+                    result = applySearchReplace(currentDescription, blocks, getOptionalBoolean(args, "allow_multiple") ?? false);
+                }
+                else {
+                    result = applyUnifiedDiff(currentDescription, patch);
+                }
+                if (getOptionalBoolean(args, "dry_run")) {
+                    return {
+                        status: "preview",
+                        dry_run: true,
+                        changes: result.changes,
+                        summary: result.summary,
+                        preview: result.preview
+                    };
+                }
+                const updatedIssue = (await context.gitlab.updateIssue(projectId, issueIid, {
+                    description: result.description
+                }));
+                let note;
+                if (getOptionalBoolean(args, "create_note")) {
+                    try {
+                        await context.gitlab.createIssueNote(projectId, issueIid, {
+                            body: `Updated issue description using patch-based tool.\n\n${result.summary}`
+                        });
+                        note = { status: "created" };
+                    }
+                    catch (error) {
+                        note = {
+                            status: "failed",
+                            message: error instanceof Error ? error.message : String(error)
+                        };
+                    }
+                }
+                return {
+                    status: "success",
+                    changes: result.changes,
+                    summary: result.summary,
+                    note,
+                    issue: {
+                        iid: updatedIssue.iid,
+                        title: updatedIssue.title,
+                        web_url: updatedIssue.web_url,
+                        updated_at: updatedIssue.updated_at
+                    }
+                };
+            }
+        },
         {
             name: "gitlab_delete_issue",
             title: "Delete Issue",
@@ -1347,25 +1896,109 @@ function getGitLabToolDefinitions() {
             }
         },
         {
-            name: "gitlab_list_issue_links",
-            title: "List Issue Links",
-            description: "List related issue links for an issue.",
+            name: "gitlab_list_issue_emoji_reactions",
+            title: "List Issue Emoji Reactions",
+            description: "List emoji reactions on an issue.",
             capabilities: readCapabilities,
             inputSchema: {
                 project_id: optionalProjectIdSchema,
-                issue_iid: z.string().min(1)
+                issue_iid: z.string().min(1),
+                ...paginationShape
             },
-            handler: async (args, context) => context.gitlab.listIssueLinks(resolveProjectId(args, context, true), getString(args, "issue_iid"))
+            handler: async (args, context) => context.gitlab.listIssueEmojiReactions(resolveProjectId(args, context, true), getString(args, "issue_iid"), { query: toQuery(omit(args, ["project_id", "issue_iid"])) })
         },
         {
-            name: "gitlab_get_issue_link",
-            title: "Get Issue Link",
-            description: "Get a single issue link by ID.",
+            name: "gitlab_list_issue_note_emoji_reactions",
+            title: "List Issue Note Emoji Reactions",
+            description: "List emoji reactions on an issue note. Pass discussion_id for discussion replies.",
             capabilities: readCapabilities,
             inputSchema: {
                 project_id: optionalProjectIdSchema,
                 issue_iid: z.string().min(1),
-                issue_link_id: z.string().min(1)
+                note_id: z.string().min(1),
+                discussion_id: optionalString,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listIssueNoteEmojiReactions(resolveProjectId(args, context, true), getString(args, "issue_iid"), getString(args, "note_id"), { discussion_id: getOptionalString(args, "discussion_id") }, { query: toQuery(omit(args, ["project_id", "issue_iid", "note_id", "discussion_id"])) })
+        },
+        {
+            name: "gitlab_create_issue_emoji_reaction",
+            title: "Create Issue Emoji Reaction",
+            description: "Add an emoji reaction to an issue, for example thumbsup, rocket, or eyes.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1),
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => context.gitlab.createIssueEmojiReaction(resolveProjectId(args, context, true), getString(args, "issue_iid"), getString(args, "name"))
+        },
+        {
+            name: "gitlab_delete_issue_emoji_reaction",
+            title: "Delete Issue Emoji Reaction",
+            description: "Delete an emoji reaction from an issue permanently. Irreversible for that reaction. Requires issue_iid and award_id. Recommended pre-check: gitlab_list_issue_emoji_reactions.",
+            capabilities: deleteCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1),
+                award_id: awardEmojiIdSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteIssueEmojiReaction(resolveProjectId(args, context, true), getString(args, "issue_iid"), getString(args, "award_id"))
+        },
+        {
+            name: "gitlab_create_issue_note_emoji_reaction",
+            title: "Create Issue Note Emoji Reaction",
+            description: "Add an emoji reaction to an issue note. Pass discussion_id for discussion replies.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1),
+                note_id: z.string().min(1),
+                discussion_id: optionalString,
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => context.gitlab.createIssueNoteEmojiReaction(resolveProjectId(args, context, true), getString(args, "issue_iid"), getString(args, "note_id"), {
+                name: getString(args, "name"),
+                discussion_id: getOptionalString(args, "discussion_id")
+            })
+        },
+        {
+            name: "gitlab_delete_issue_note_emoji_reaction",
+            title: "Delete Issue Note Emoji Reaction",
+            description: "Delete an emoji reaction from an issue note permanently. Irreversible for that reaction. Requires issue_iid, note_id, and award_id. Recommended pre-check: gitlab_list_issue_note_emoji_reactions.",
+            capabilities: deleteCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1),
+                note_id: z.string().min(1),
+                discussion_id: optionalString,
+                award_id: awardEmojiIdSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteIssueNoteEmojiReaction(resolveProjectId(args, context, true), getString(args, "issue_iid"), getString(args, "note_id"), {
+                award_id: getString(args, "award_id"),
+                discussion_id: getOptionalString(args, "discussion_id")
+            })
+        },
+        {
+            name: "gitlab_list_issue_links",
+            title: "List Issue Links",
+            description: "List related issue links for an issue.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1)
+            },
+            handler: async (args, context) => context.gitlab.listIssueLinks(resolveProjectId(args, context, true), getString(args, "issue_iid"))
+        },
+        {
+            name: "gitlab_get_issue_link",
+            title: "Get Issue Link",
+            description: "Get a single issue link by ID.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                issue_iid: z.string().min(1),
+                issue_link_id: z.string().min(1)
             },
             handler: async (args, context) => context.gitlab.getIssueLink(resolveProjectId(args, context, true), getString(args, "issue_iid"), getString(args, "issue_link_id"))
         },
@@ -1478,6 +2111,87 @@ function getGitLabToolDefinitions() {
             },
             handler: async (args, context) => context.gitlab.deleteWikiPage(resolveProjectId(args, context, true), getString(args, "slug"))
         },
+        {
+            name: "gitlab_list_group_wiki_pages",
+            title: "List Group Wiki Pages",
+            description: "List wiki pages in a group.",
+            capabilities: readCapabilities,
+            requiresFeature: "wiki",
+            inputSchema: {
+                group_id: projectIdSchema,
+                with_content: optionalBoolean,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listGroupWikiPages(getString(args, "group_id"), {
+                query: toQuery(omit(args, ["group_id"]))
+            })
+        },
+        {
+            name: "gitlab_get_group_wiki_page",
+            title: "Get Group Wiki Page",
+            description: "Get group wiki page by slug.",
+            capabilities: readCapabilities,
+            requiresFeature: "wiki",
+            inputSchema: {
+                group_id: projectIdSchema,
+                slug: slugSchema,
+                version: optionalString
+            },
+            handler: async (args, context) => context.gitlab.getGroupWikiPage(getString(args, "group_id"), getString(args, "slug"), {
+                query: toQuery(omit(args, ["group_id", "slug"]))
+            })
+        },
+        {
+            name: "gitlab_create_group_wiki_page",
+            title: "Create Group Wiki Page",
+            description: "Create a group wiki page.",
+            capabilities: writeCapabilities,
+            requiresFeature: "wiki",
+            inputSchema: {
+                group_id: projectIdSchema,
+                title: z.string().min(1),
+                content: z.string().min(1),
+                format: optionalString
+            },
+            handler: async (args, context) => context.gitlab.createGroupWikiPage(getString(args, "group_id"), {
+                title: getString(args, "title"),
+                content: getString(args, "content"),
+                format: getOptionalString(args, "format")
+            })
+        },
+        {
+            name: "gitlab_update_group_wiki_page",
+            title: "Update Group Wiki Page",
+            description: "Update group wiki page by slug.",
+            capabilities: writeCapabilities,
+            requiresFeature: "wiki",
+            inputSchema: {
+                group_id: projectIdSchema,
+                slug: slugSchema,
+                title: optionalString,
+                content: optionalString,
+                format: optionalString
+            },
+            handler: async (args, context) => {
+                const payload = toQuery(omit(args, ["group_id", "slug"]));
+                if (Object.keys(payload).length === 0) {
+                    throw new Error("At least one of title, content, or format must be provided");
+                }
+                return context.gitlab.updateGroupWikiPage(getString(args, "group_id"), getString(args, "slug"), payload);
+            }
+        },
+        {
+            name: "gitlab_delete_group_wiki_page",
+            title: "Delete Group Wiki Page",
+            description: "Delete a group wiki page permanently. Irreversible. Requires group_id and slug. Recommended pre-check: gitlab_get_group_wiki_page or gitlab_list_group_wiki_pages.",
+            capabilities: deleteCapabilities,
+            requiresFeature: "wiki",
+            inputSchema: {
+                group_id: projectIdSchema,
+                slug: slugSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteGroupWikiPage(getString(args, "group_id"), getString(args, "slug"))
+        },
         {
             name: "gitlab_list_pipelines",
             title: "List Pipelines",
@@ -1673,6 +2387,38 @@ function getGitLabToolDefinitions() {
             },
             handler: async (args, context) => context.gitlab.getPipelineJobOutput(resolveProjectId(args, context, true), getString(args, "job_id"))
         },
+        {
+            name: "gitlab_validate_ci_lint",
+            title: "Validate CI Lint",
+            description: "Validate provided GitLab CI/CD YAML content for a project.",
+            capabilities: readCapabilities,
+            requiresFeature: "pipeline",
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                content: z.string().min(1),
+                dry_run: optionalBoolean,
+                include_jobs: optionalBoolean,
+                ref: optionalRefLikeSchema
+            },
+            handler: async (args, context) => withCiLintHttpDiagnostics(() => context.gitlab.validateCiLint(resolveProjectId(args, context, true), toQuery(omit(args, ["project_id"]))))
+        },
+        {
+            name: "gitlab_validate_project_ci_lint",
+            title: "Validate Project CI Lint",
+            description: "Validate an existing project CI/CD configuration.",
+            capabilities: readCapabilities,
+            requiresFeature: "pipeline",
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                content_ref: optionalRefLikeSchema,
+                dry_run: optionalBoolean,
+                dry_run_ref: optionalRefLikeSchema,
+                include_jobs: optionalBoolean
+            },
+            handler: async (args, context) => withCiLintHttpDiagnostics(() => context.gitlab.validateProjectCiLint(resolveProjectId(args, context, true), {
+                query: toQuery(omit(args, ["project_id"]))
+            }))
+        },
         {
             name: "gitlab_list_job_artifacts",
             title: "List Job Artifacts",
@@ -1697,7 +2443,17 @@ function getGitLabToolDefinitions() {
                 project_id: optionalProjectIdSchema,
                 job_id: z.string().min(1)
             },
-            handler: async (args, context) => context.gitlab.downloadJobArtifacts(resolveProjectId(args, context, true), getString(args, "job_id"))
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const jobId = getString(args, "job_id");
+                if (shouldReturnDownloadProxy(context)) {
+                    return buildDownloadProxyResult(context, {
+                        type: "job-artifacts",
+                        params: { project_id: projectId, job_id: jobId }
+                    }, `artifacts_job_${jobId}.zip`);
+                }
+                return context.gitlab.downloadJobArtifacts(projectId, jobId);
+            }
         },
         {
             name: "gitlab_download_job_artifacts_local",
@@ -2075,7 +2831,84 @@ function getGitLabToolDefinitions() {
                 tag_name: refLikeSchema,
                 direct_asset_path: z.string().min(1)
             },
-            handler: async (args, context) => context.gitlab.downloadReleaseAsset(resolveProjectId(args, context, true), getString(args, "tag_name"), getString(args, "direct_asset_path"))
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const tagName = getString(args, "tag_name");
+                const directAssetPath = getString(args, "direct_asset_path");
+                if (shouldReturnDownloadProxy(context)) {
+                    return buildDownloadProxyResult(context, {
+                        type: "release-asset",
+                        params: {
+                            project_id: projectId,
+                            tag_name: tagName,
+                            direct_asset_path: directAssetPath
+                        }
+                    }, directAssetPath.split("/").pop() || directAssetPath);
+                }
+                return context.gitlab.downloadReleaseAsset(projectId, tagName, directAssetPath);
+            }
+        },
+        {
+            name: "gitlab_list_tags",
+            title: "List Tags",
+            description: "List repository tags for a project.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                order_by: z.enum(["name", "updated", "version"]).optional(),
+                sort: z.enum(["asc", "desc"]).optional(),
+                search: optionalString,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listTags(resolveProjectId(args, context, true), {
+                query: toQuery(omit(args, ["project_id"]))
+            })
+        },
+        {
+            name: "gitlab_get_tag",
+            title: "Get Tag",
+            description: "Get a repository tag by name.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                tag_name: refLikeSchema
+            },
+            handler: async (args, context) => context.gitlab.getTag(resolveProjectId(args, context, true), getString(args, "tag_name"))
+        },
+        {
+            name: "gitlab_create_tag",
+            title: "Create Tag",
+            description: "Create a repository tag from a branch, commit SHA, or another tag.",
+            capabilities: writeCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                tag_name: refLikeSchema,
+                ref: refLikeSchema,
+                message: optionalString
+            },
+            handler: async (args, context) => context.gitlab.createTag(resolveProjectId(args, context, true), toQuery(omit(args, ["project_id"])))
+        },
+        {
+            name: "gitlab_delete_tag",
+            title: "Delete Tag",
+            description: "Delete a repository tag permanently. Irreversible for tag_name. Requires tag_name. Recommended pre-check: gitlab_get_tag or gitlab_list_tags.",
+            capabilities: deleteCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                tag_name: refLikeSchema
+            },
+            handler: async (args, context) => context.gitlab.deleteTag(resolveProjectId(args, context, true), getString(args, "tag_name"))
+        },
+        {
+            name: "gitlab_get_tag_signature",
+            title: "Get Tag Signature",
+            description: "Get the X.509 signature for a signed repository tag.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                tag_name: refLikeSchema
+            },
+            handler: async (args, context) => context.gitlab.getTagSignature(resolveProjectId(args, context, true), getString(args, "tag_name"))
         },
         {
             name: "gitlab_list_labels",
@@ -2219,6 +3052,24 @@ function getGitLabToolDefinitions() {
             },
             handler: async (args, context) => context.gitlab.getUsers({ query: toQuery(args) })
         },
+        {
+            name: "gitlab_get_user",
+            title: "Get User",
+            description: "Get one user by ID.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                user_id: z.string().min(1)
+            },
+            handler: async (args, context) => context.gitlab.getUser(getString(args, "user_id"))
+        },
+        {
+            name: "gitlab_whoami",
+            title: "Who Am I",
+            description: "Get the current authenticated user.",
+            capabilities: readCapabilities,
+            inputSchema: {},
+            handler: async (_args, context) => context.gitlab.whoami()
+        },
         {
             name: "gitlab_list_events",
             title: "List Events",
@@ -2253,6 +3104,69 @@ function getGitLabToolDefinitions() {
                 query: toQuery(omit(args, ["project_id"]))
             })
         },
+        {
+            name: "gitlab_list_webhooks",
+            title: "List Webhooks",
+            description: "List configured webhooks for a project or group.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                group_id: optionalProjectIdSchema,
+                ...paginationShape
+            },
+            handler: async (args, context) => context.gitlab.listWebhooks(resolveWebhookScope(args), {
+                query: toQuery(omit(args, ["project_id", "group_id"]))
+            })
+        },
+        {
+            name: "gitlab_list_webhook_events",
+            title: "List Webhook Events",
+            description: "List recent webhook events for a project or group webhook. Use summary mode for overviews.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                group_id: optionalProjectIdSchema,
+                hook_id: z.union([z.string(), z.number()]),
+                status: optionalStringOrNumber,
+                summary: optionalBoolean,
+                page: optionalNumber,
+                per_page: z.number().int().min(1).max(20).optional()
+            },
+            handler: async (args, context) => {
+                const events = extractRecords(await context.gitlab.listWebhookEvents(resolveWebhookScope(args), getIdString(args, "hook_id"), {
+                    query: toQuery({
+                        status: args.status,
+                        page: args.page,
+                        per_page: args.per_page ?? 20
+                    })
+                }));
+                return getOptionalBoolean(args, "summary") ? summarizeWebhookEvents(events) : events;
+            }
+        },
+        {
+            name: "gitlab_get_webhook_event",
+            title: "Get Webhook Event",
+            description: "Find one webhook event by ID. Provide page when known, otherwise scans up to 500 recent events.",
+            capabilities: readCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                group_id: optionalProjectIdSchema,
+                hook_id: z.union([z.string(), z.number()]),
+                event_id: z.union([z.string(), z.number()]),
+                page: optionalNumber
+            },
+            handler: async (args, context) => {
+                const event = await findWebhookEvent(context, resolveWebhookScope(args), getIdString(args, "hook_id"), getIdString(args, "event_id"), getOptionalNumber(args, "page"));
+                if (event) {
+                    return event;
+                }
+                return {
+                    error: `Webhook event ${getIdString(args, "event_id")} not found ${getOptionalNumber(args, "page")
+                        ? `on page ${getOptionalNumber(args, "page")}`
+                        : "in the 500 most recent events"}`
+                };
+            }
+        },
         {
             name: "gitlab_upload_markdown",
             title: "Upload Markdown",
@@ -2268,6 +3182,9 @@ function getGitLabToolDefinitions() {
                 const projectId = resolveProjectId(args, context, true);
                 const filePath = getOptionalString(args, "file_path");
                 if (filePath) {
+                    if (!context.allowLocalFileTools) {
+                        throw new Error("file_path cannot be used over HTTP. Provide content and filename.");
+                    }
                     return context.gitlab.uploadMarkdownFile(projectId, filePath);
                 }
                 const content = getOptionalString(args, "content");
@@ -2300,10 +3217,30 @@ function getGitLabToolDefinitions() {
                         if (!upload) {
                             throw new Error("In project-scoped mode, url_or_path must be a GitLab upload URL/path like '/uploads/<secret>/<filename>'");
                         }
+                        if (shouldReturnDownloadProxy(context)) {
+                            return buildDownloadProxyResult(context, {
+                                type: "attachment",
+                                params: {
+                                    project_id: projectId,
+                                    secret: upload.secret,
+                                    filename: upload.filename
+                                }
+                            }, upload.filename);
+                        }
                         const apiRelativePath = `api/v4/projects/${encodeURIComponent(projectId)}/uploads/${encodeURIComponent(upload.secret)}/${encodeURIComponent(upload.filename)}`;
                         return context.gitlab.downloadAttachment(apiRelativePath);
                     }
                     if (projectId && upload) {
+                        if (shouldReturnDownloadProxy(context)) {
+                            return buildDownloadProxyResult(context, {
+                                type: "attachment",
+                                params: {
+                                    project_id: projectId,
+                                    secret: upload.secret,
+                                    filename: upload.filename
+                                }
+                            }, upload.filename);
+                        }
                         const apiRelativePath = `api/v4/projects/${encodeURIComponent(projectId)}/uploads/${encodeURIComponent(upload.secret)}/${encodeURIComponent(upload.filename)}`;
                         return context.gitlab.downloadAttachment(apiRelativePath);
                     }
@@ -2316,53 +3253,390 @@ function getGitLabToolDefinitions() {
                 }
                 const projectId = resolveProjectId(args, context, true);
                 const apiRelativePath = `api/v4/projects/${encodeURIComponent(projectId)}/uploads/${encodeURIComponent(secret)}/${encodeURIComponent(filename)}`;
+                if (shouldReturnDownloadProxy(context)) {
+                    return buildDownloadProxyResult(context, {
+                        type: "attachment",
+                        params: { project_id: projectId, secret, filename }
+                    }, filename);
+                }
                 return context.gitlab.downloadAttachment(apiRelativePath);
             }
         },
         {
-            name: "gitlab_execute_graphql_query",
-            title: "Execute GraphQL Query",
-            description: "Execute read-only GraphQL query.",
+            name: "gitlab_get_work_item",
+            title: "Get Work Item",
+            description: "Get a single work item with full widget details including status, hierarchy, labels, assignees, linked items, custom fields, and development data.",
             capabilities: readGraphqlCapabilities,
             inputSchema: {
-                query: z.string().min(1),
-                variables: optionalRecord
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema
             },
-            handler: async (args, context) => {
-                const query = getString(args, "query");
-                if (containsGraphqlMutation(query)) {
-                    throw new Error("Mutation detected. Use gitlab_execute_graphql_mutation for mutation operations.");
-                }
-                return context.gitlab.executeGraphql(query, getOptionalRecord(args, "variables"));
-            }
+            handler: async (args, context) => getWorkItem(context, resolveProjectId(args, context, true), getNumber(args, "iid"))
         },
         {
-            name: "gitlab_execute_graphql_mutation",
-            title: "Execute GraphQL Mutation",
-            description: "Execute GraphQL mutation (disabled in read-only mode).",
-            capabilities: writeGraphqlCapabilities,
+            name: "gitlab_list_work_items",
+            title: "List Work Items",
+            description: "List work items in a project with filters for type, state, search, assignees, and labels.",
+            capabilities: readGraphqlCapabilities,
             inputSchema: {
-                query: z.string().min(1),
-                variables: optionalRecord
+                project_id: optionalProjectIdSchema,
+                types: nullableOptional(z.array(workItemTypeSchema)),
+                state: z.enum(["opened", "closed"]).optional(),
+                search: optionalString,
+                assignee_usernames: optionalStringArray,
+                label_names: optionalStringArray,
+                first: z.coerce.number().int().positive().max(100).optional(),
+                after: optionalString
             },
-            handler: async (args, context) => {
-                const query = getString(args, "query");
-                if (!containsGraphqlMutation(query)) {
-                    throw new Error("No mutation detected. Use gitlab_execute_graphql_query for queries.");
-                }
-                return context.gitlab.executeGraphql(query, getOptionalRecord(args, "variables"));
-            }
+            handler: async (args, context) => listWorkItems(context, resolveProjectId(args, context, true), {
+                types: getOptionalStringArray(args, "types"),
+                state: getOptionalString(args, "state"),
+                search: getOptionalString(args, "search"),
+                assigneeUsernames: getOptionalStringArray(args, "assignee_usernames"),
+                labelNames: getOptionalStringArray(args, "label_names"),
+                first: getOptionalNumber(args, "first"),
+                after: getOptionalString(args, "after")
+            })
         },
         {
-            name: "gitlab_execute_graphql",
-            title: "Execute GraphQL (Compat)",
-            description: "Backward-compatible GraphQL executor. Mutation payloads still honor read-only policy.",
-            capabilities: readGraphqlCapabilities,
+            name: "gitlab_create_work_item",
+            title: "Create Work Item",
+            description: "Create a work item of type issue, task, incident, test_case, epic, key_result, objective, requirement, or ticket.",
+            capabilities: writeGraphqlCapabilities,
             inputSchema: {
-                query: z.string().min(1),
-                variables: optionalRecord
-            },
-            handler: async (args, context) => {
+                project_id: optionalProjectIdSchema,
+                title: z.string().min(1),
+                type: optionalWorkItemType,
+                description: optionalString,
+                labels: optionalStringArray,
+                assignee_usernames: optionalStringArray,
+                parent_iid: workItemIidSchema.optional(),
+                weight: optionalCoercedNumber,
+                health_status: z.enum(["onTrack", "needsAttention", "atRisk"]).optional(),
+                start_date: optionalString,
+                due_date: optionalString,
+                milestone_id: optionalString,
+                iteration_id: optionalString,
+                confidential: optionalCoercedBoolean
+            },
+            handler: async (args, context) => createWorkItem(context, resolveProjectId(args, context, true), {
+                title: getString(args, "title"),
+                type: getOptionalString(args, "type"),
+                description: getOptionalString(args, "description"),
+                labels: getOptionalStringArray(args, "labels"),
+                assigneeUsernames: getOptionalStringArray(args, "assignee_usernames"),
+                parentIid: getOptionalNumber(args, "parent_iid"),
+                weight: getOptionalNumber(args, "weight"),
+                healthStatus: getOptionalString(args, "health_status"),
+                startDate: getOptionalString(args, "start_date"),
+                dueDate: getOptionalString(args, "due_date"),
+                milestoneId: getOptionalString(args, "milestone_id"),
+                iterationId: getOptionalString(args, "iteration_id"),
+                confidential: getOptionalBoolean(args, "confidential")
+            })
+        },
+        {
+            name: "gitlab_update_work_item",
+            title: "Update Work Item",
+            description: "Update a work item title, description, labels, assignees, state, status, hierarchy, linked items, custom fields, dates, milestone, iteration, and incident metadata.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                title: optionalString,
+                description: optionalString,
+                add_labels: optionalStringArray,
+                remove_labels: optionalStringArray,
+                assignee_usernames: optionalStringArray,
+                state_event: z.enum(["close", "reopen"]).optional(),
+                weight: optionalNumber,
+                status: optionalString,
+                parent_iid: workItemIidSchema.optional(),
+                parent_project_id: optionalProjectIdSchema,
+                remove_parent: optionalCoercedBoolean,
+                children_to_add: nullableOptional(z.array(workItemReferenceSchema)),
+                children_to_remove: nullableOptional(z.array(workItemReferenceSchema)),
+                health_status: z.enum(["onTrack", "needsAttention", "atRisk"]).optional(),
+                start_date: optionalString,
+                due_date: optionalString,
+                milestone_id: optionalString,
+                iteration_id: optionalString,
+                confidential: optionalCoercedBoolean,
+                linked_items_to_add: nullableOptional(z.array(linkedWorkItemReferenceSchema)),
+                linked_items_to_remove: nullableOptional(z.array(workItemReferenceSchema)),
+                custom_fields: nullableOptional(z.array(customFieldValueSchema)),
+                severity: z.enum(["UNKNOWN", "LOW", "MEDIUM", "HIGH", "CRITICAL"]).optional(),
+                escalation_status: z.enum(["TRIGGERED", "ACKNOWLEDGED", "RESOLVED", "IGNORED"]).optional()
+            },
+            handler: async (args, context) => updateWorkItem(context, resolveProjectId(args, context, true), getNumber(args, "iid"), {
+                title: getOptionalString(args, "title"),
+                description: getOptionalString(args, "description"),
+                addLabels: getOptionalStringArray(args, "add_labels"),
+                removeLabels: getOptionalStringArray(args, "remove_labels"),
+                assigneeUsernames: getOptionalStringArray(args, "assignee_usernames"),
+                stateEvent: getOptionalString(args, "state_event"),
+                weight: getOptionalNumber(args, "weight"),
+                status: getOptionalString(args, "status"),
+                parentIid: getOptionalNumber(args, "parent_iid"),
+                parentProjectId: getOptionalString(args, "parent_project_id"),
+                removeParent: getOptionalBoolean(args, "remove_parent"),
+                childrenToAdd: getWorkItemReferences(args, "children_to_add", context),
+                childrenToRemove: getWorkItemReferences(args, "children_to_remove", context),
+                healthStatus: getOptionalString(args, "health_status"),
+                startDate: getOptionalString(args, "start_date"),
+                dueDate: getOptionalString(args, "due_date"),
+                milestoneId: getOptionalString(args, "milestone_id"),
+                iterationId: getOptionalString(args, "iteration_id"),
+                confidential: getOptionalBoolean(args, "confidential"),
+                linkedItemsToAdd: getLinkedWorkItemReferences(args, "linked_items_to_add", context),
+                linkedItemsToRemove: getWorkItemReferences(args, "linked_items_to_remove", context),
+                customFields: getOptionalArray(args, "custom_fields"),
+                severity: getOptionalString(args, "severity"),
+                escalationStatus: getOptionalString(args, "escalation_status")
+            })
+        },
+        {
+            name: "gitlab_convert_work_item_type",
+            title: "Convert Work Item Type",
+            description: "Convert a work item to a different type.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                new_type: workItemTypeSchema
+            },
+            handler: async (args, context) => convertWorkItemType(context, resolveProjectId(args, context, true), getNumber(args, "iid"), getString(args, "new_type"))
+        },
+        {
+            name: "gitlab_list_work_item_statuses",
+            title: "List Work Item Statuses",
+            description: "List available statuses and allowed hierarchy/conversion types for a work item type.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                work_item_type: optionalWorkItemType
+            },
+            handler: async (args, context) => listWorkItemStatuses(context, resolveProjectId(args, context, true), getOptionalString(args, "work_item_type") ?? "issue")
+        },
+        {
+            name: "gitlab_list_custom_field_definitions",
+            title: "List Custom Field Definitions",
+            description: "List custom field definitions for a work item type, including field IDs, types, options, and supported work item types.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                work_item_type: optionalWorkItemType
+            },
+            handler: async (args, context) => listCustomFieldDefinitions(context, resolveProjectId(args, context, true), getOptionalString(args, "work_item_type") ?? "issue")
+        },
+        {
+            name: "gitlab_move_work_item",
+            title: "Move Work Item",
+            description: "Move a work item to a different project.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                target_project_id: projectIdSchema
+            },
+            handler: async (args, context) => moveWorkItem(context, resolveProjectId(args, context, true), getNumber(args, "iid"), resolveExplicitProjectId(context, getString(args, "target_project_id")))
+        },
+        {
+            name: "gitlab_list_work_item_notes",
+            title: "List Work Item Notes",
+            description: "List threaded discussions and notes on a work item.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                page_size: z.coerce.number().int().positive().max(100).optional(),
+                after: optionalString,
+                sort: z.enum(["CREATED_ASC", "CREATED_DESC"]).optional()
+            },
+            handler: async (args, context) => listWorkItemNotes(context, resolveProjectId(args, context, true), getNumber(args, "iid"), {
+                pageSize: getOptionalNumber(args, "page_size"),
+                after: getOptionalString(args, "after"),
+                sort: getOptionalString(args, "sort")
+            })
+        },
+        {
+            name: "gitlab_create_work_item_note",
+            title: "Create Work Item Note",
+            description: "Add a note or threaded reply to a work item.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                body: bodySchema,
+                internal: optionalCoercedBoolean,
+                discussion_id: optionalString
+            },
+            handler: async (args, context) => createWorkItemNote(context, resolveProjectId(args, context, true), getNumber(args, "iid"), getString(args, "body"), {
+                internal: getOptionalBoolean(args, "internal"),
+                discussionId: getOptionalString(args, "discussion_id")
+            })
+        },
+        {
+            name: "gitlab_list_work_item_emoji_reactions",
+            title: "List Work Item Emoji Reactions",
+            description: "List emoji reactions on a work item.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema
+            },
+            handler: async (args, context) => listGraphqlAwardEmoji(context, (await resolveWorkItemGid(context, resolveProjectId(args, context, true), getNumber(args, "iid"))).workItemGid)
+        },
+        {
+            name: "gitlab_list_work_item_note_emoji_reactions",
+            title: "List Work Item Note Emoji Reactions",
+            description: "List emoji reactions on a work item note by GraphQL note_id.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                note_id: z.string().min(1)
+            },
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const noteId = await resolveWorkItemNoteAwardableId(context, projectId, getNumber(args, "iid"), getString(args, "note_id"));
+                return listGraphqlAwardEmoji(context, noteId);
+            }
+        },
+        {
+            name: "gitlab_create_work_item_emoji_reaction",
+            title: "Create Work Item Emoji Reaction",
+            description: "Add an emoji reaction to a work item, for example thumbsup, rocket, or eyes.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => addGraphqlAwardEmoji(context, (await resolveWorkItemGid(context, resolveProjectId(args, context, true), getNumber(args, "iid"))).workItemGid, getString(args, "name"))
+        },
+        {
+            name: "gitlab_delete_work_item_emoji_reaction",
+            title: "Delete Work Item Emoji Reaction",
+            description: "Remove the current user's emoji reaction from a work item by emoji name. Requires iid and name.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => removeGraphqlAwardEmoji(context, (await resolveWorkItemGid(context, resolveProjectId(args, context, true), getNumber(args, "iid"))).workItemGid, getString(args, "name"))
+        },
+        {
+            name: "gitlab_create_work_item_note_emoji_reaction",
+            title: "Create Work Item Note Emoji Reaction",
+            description: "Add an emoji reaction to a work item note by GraphQL note_id.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                note_id: z.string().min(1),
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const noteId = await resolveWorkItemNoteAwardableId(context, projectId, getNumber(args, "iid"), getString(args, "note_id"));
+                return addGraphqlAwardEmoji(context, noteId, getString(args, "name"));
+            }
+        },
+        {
+            name: "gitlab_delete_work_item_note_emoji_reaction",
+            title: "Delete Work Item Note Emoji Reaction",
+            description: "Remove the current user's emoji reaction from a work item note by GraphQL note_id and emoji name.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                iid: workItemIidSchema,
+                note_id: z.string().min(1),
+                name: emojiNameSchema
+            },
+            handler: async (args, context) => {
+                const projectId = resolveProjectId(args, context, true);
+                const noteId = await resolveWorkItemNoteAwardableId(context, projectId, getNumber(args, "iid"), getString(args, "note_id"));
+                return removeGraphqlAwardEmoji(context, noteId, getString(args, "name"));
+            }
+        },
+        {
+            name: "gitlab_get_timeline_events",
+            title: "Get Timeline Events",
+            description: "List timeline events for an incident work item.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                incident_iid: workItemIidSchema
+            },
+            handler: async (args, context) => getTimelineEvents(context, resolveProjectId(args, context, true), getNumber(args, "incident_iid"))
+        },
+        {
+            name: "gitlab_create_timeline_event",
+            title: "Create Timeline Event",
+            description: "Create an incident timeline event with optional known GitLab incident timeline tags.",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                project_id: optionalProjectIdSchema,
+                incident_iid: workItemIidSchema,
+                note: bodySchema,
+                occurred_at: z.string().min(1),
+                tag_names: nullableOptional(z.array(z.enum([
+                    "Start time",
+                    "End time",
+                    "Impact detected",
+                    "Response initiated",
+                    "Impact mitigated",
+                    "Cause identified"
+                ])))
+            },
+            handler: async (args, context) => createTimelineEvent(context, resolveProjectId(args, context, true), getNumber(args, "incident_iid"), getString(args, "note"), getString(args, "occurred_at"), getOptionalStringArray(args, "tag_names"))
+        },
+        {
+            name: "gitlab_execute_graphql_query",
+            title: "Execute GraphQL Query",
+            description: "Execute read-only GraphQL query.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                query: z.string().min(1),
+                variables: optionalRecord
+            },
+            handler: async (args, context) => {
+                const query = getString(args, "query");
+                if (containsGraphqlMutation(query)) {
+                    throw new Error("Mutation detected. Use gitlab_execute_graphql_mutation for mutation operations.");
+                }
+                return context.gitlab.executeGraphql(query, getOptionalRecord(args, "variables"));
+            }
+        },
+        {
+            name: "gitlab_execute_graphql_mutation",
+            title: "Execute GraphQL Mutation",
+            description: "Execute GraphQL mutation (disabled in read-only mode).",
+            capabilities: writeGraphqlCapabilities,
+            inputSchema: {
+                query: z.string().min(1),
+                variables: optionalRecord
+            },
+            handler: async (args, context) => {
+                const query = getString(args, "query");
+                if (!containsGraphqlMutation(query)) {
+                    throw new Error("No mutation detected. Use gitlab_execute_graphql_query for queries.");
+                }
+                return context.gitlab.executeGraphql(query, getOptionalRecord(args, "variables"));
+            }
+        },
+        {
+            name: "gitlab_execute_graphql",
+            title: "Execute GraphQL (Compat)",
+            description: "Backward-compatible GraphQL executor. Mutation payloads still honor read-only policy.",
+            capabilities: readGraphqlCapabilities,
+            inputSchema: {
+                query: z.string().min(1),
+                variables: optionalRecord
+            },
+            handler: async (args, context) => {
                 const query = getString(args, "query");
                 if (containsGraphqlMutation(query)) {
                     context.policy.assertCanExecute({
@@ -2375,12 +3649,65 @@ function getGitLabToolDefinitions() {
         }
     ];
 }
+function shouldReturnDownloadProxy(context) {
+    return !context.allowLocalFileTools && resolveDownloadTokenAuth(context) !== undefined;
+}
+function buildDownloadProxyResult(context, resource, filename) {
+    return {
+        download_url: buildDownloadProxyUrl(context, resource),
+        filename,
+        expires_in_seconds: context.env.GITLAB_DOWNLOAD_TOKEN_TTL_SECONDS
+    };
+}
+function buildDownloadProxyUrl(context, resource) {
+    const baseUrl = new URL(context.env.MCP_SERVER_URL ?? `http://${context.env.HTTP_HOST}:${String(context.env.HTTP_PORT)}`);
+    const basePath = baseUrl.pathname.replace(/\/+$/, "");
+    const url = new URL(`${basePath}/downloads/${encodeURIComponent(resource.type)}`, baseUrl.origin);
+    for (const [key, value] of Object.entries(resource.params)) {
+        url.searchParams.set(key, value);
+    }
+    const tokenAuth = resolveDownloadTokenAuth(context);
+    if (tokenAuth) {
+        url.searchParams.set("_token", createDownloadToken(tokenAuth, resource, {
+            secret: context.env.GITLAB_DOWNLOAD_TOKEN_SECRET,
+            ttlSeconds: context.env.GITLAB_DOWNLOAD_TOKEN_TTL_SECONDS
+        }));
+    }
+    return url.toString();
+}
+function resolveDownloadTokenAuth(context) {
+    const sessionAuth = getSessionAuth();
+    if (sessionAuth?.token) {
+        return {
+            header: sessionAuth.header ?? "private-token",
+            token: sessionAuth.token,
+            apiUrl: context.env.ENABLE_DYNAMIC_API_URL && sessionAuth.apiUrl !== context.env.GITLAB_API_URL
+                ? sessionAuth.apiUrl
+                : undefined
+        };
+    }
+    if (context.env.GITLAB_PERSONAL_ACCESS_TOKEN) {
+        return {
+            header: "private-token",
+            token: context.env.GITLAB_PERSONAL_ACCESS_TOKEN
+        };
+    }
+    if (context.env.GITLAB_JOB_TOKEN) {
+        return {
+            header: "job-token",
+            token: context.env.GITLAB_JOB_TOKEN
+        };
+    }
+    return undefined;
+}
 function assertAuthReady(context) {
     const auth = getSessionAuth();
-    if (context.env.REMOTE_AUTHORIZATION) {
+    if (context.env.REMOTE_AUTHORIZATION || context.env.GITLAB_MCP_OAUTH) {
         const token = auth?.token;
         if (!token) {
-            throw new Error("Missing remote authorization token for this session");
+            throw new Error(context.env.REMOTE_AUTHORIZATION
+                ? "Missing remote authorization token for this session"
+                : "Missing OAuth authorization token for this session");
         }
         if (context.env.ENABLE_DYNAMIC_API_URL && !auth?.apiUrl) {
             throw new Error("Missing remote API URL for this session");
@@ -2388,14 +3715,1032 @@ function assertAuthReady(context) {
         return;
     }
     const hasFallbackAuth = Boolean(context.env.GITLAB_PERSONAL_ACCESS_TOKEN) ||
+        Boolean(context.env.GITLAB_JOB_TOKEN) ||
         Boolean(context.env.GITLAB_USE_OAUTH && context.env.GITLAB_OAUTH_CLIENT_ID) ||
         Boolean(context.env.GITLAB_TOKEN_SCRIPT) ||
         Boolean(context.env.GITLAB_TOKEN_FILE) ||
         Boolean(context.env.GITLAB_AUTH_COOKIE_PATH);
     if (!hasFallbackAuth) {
-        throw new Error("Authentication required: set GITLAB_PERSONAL_ACCESS_TOKEN, GITLAB_TOKEN_SCRIPT, GITLAB_TOKEN_FILE, or GITLAB_AUTH_COOKIE_PATH");
+        throw new Error("Authentication required: set GITLAB_PERSONAL_ACCESS_TOKEN, GITLAB_JOB_TOKEN, GITLAB_TOKEN_SCRIPT, GITLAB_TOKEN_FILE, or GITLAB_AUTH_COOKIE_PATH");
+    }
+}
+const WORK_ITEM_TYPE_NAMES = {
+    issue: "Issue",
+    task: "Task",
+    incident: "Incident",
+    test_case: "Test Case",
+    epic: "Epic",
+    key_result: "Key Result",
+    objective: "Objective",
+    requirement: "Requirement",
+    ticket: "Ticket"
+};
+const WORK_ITEM_GRAPHQL_TYPES = {
+    issue: "ISSUE",
+    task: "TASK",
+    incident: "INCIDENT",
+    test_case: "TEST_CASE",
+    epic: "EPIC",
+    key_result: "KEY_RESULT",
+    objective: "OBJECTIVE",
+    requirement: "REQUIREMENT",
+    ticket: "TICKET"
+};
+async function executeGraphqlData(context, query, variables = {}) {
+    const response = (await context.gitlab.executeGraphql(query, variables));
+    if (typeof response === "object" &&
+        response !== null &&
+        "errors" in response &&
+        Array.isArray(response.errors)) {
+        const errors = response.errors;
+        throw new Error(`GraphQL errors: ${errors.map((item) => item.message ?? String(item)).join(", ")}`);
+    }
+    if (typeof response === "object" && response !== null && "data" in response) {
+        return response.data;
+    }
+    return response;
+}
+function resolveExplicitProjectId(context, projectId) {
+    const allowed = context.env.GITLAB_ALLOWED_PROJECT_IDS;
+    if (allowed.length > 0 && !allowed.includes(projectId)) {
+        throw new Error(`Project '${projectId}' is not in GITLAB_ALLOWED_PROJECT_IDS: ${allowed.join(", ")}`);
+    }
+    return projectId;
+}
+async function resolveProjectPathForWorkItem(context, projectId) {
+    const project = (await context.gitlab.getProject(projectId));
+    const pathWithNamespace = project.path_with_namespace;
+    if (typeof pathWithNamespace === "string" && pathWithNamespace.length > 0) {
+        return pathWithNamespace;
+    }
+    if (projectId.includes("/")) {
+        return projectId;
+    }
+    throw new Error(`Project '${projectId}' did not include path_with_namespace`);
+}
+async function resolveWorkItemGid(context, projectId, iid) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const data = await executeGraphqlData(context, `query($path: ID!, $iid: String!) {
+      namespace(fullPath: $path) {
+        workItem(iid: $iid) { id }
+      }
+    }`, { path: projectPath, iid: String(iid) });
+    const workItemGid = data.namespace?.workItem?.id;
+    if (!workItemGid) {
+        throw new Error(`Work item #${iid} not found in project ${projectPath}`);
+    }
+    return { workItemGid, projectPath };
+}
+async function resolveWorkItemTypeGid(context, projectPath, type) {
+    const targetName = WORK_ITEM_TYPE_NAMES[type];
+    const data = await executeGraphqlData(context, `query($path: ID!) {
+      namespace(fullPath: $path) {
+        workItemTypes { nodes { id name } }
+      }
+    }`, { path: projectPath });
+    const match = data.namespace?.workItemTypes?.nodes?.find((item) => item.name === targetName);
+    if (!match) {
+        throw new Error(`Work item type '${targetName}' not found in project ${projectPath}`);
     }
+    return match.id;
 }
+async function resolveNamesToIds(context, projectPath, labelNames, usernames) {
+    if ((!labelNames || labelNames.length === 0) && (!usernames || usernames.length === 0)) {
+        return { labelIds: [], userIds: [] };
+    }
+    const data = await executeGraphqlData(context, `query($path: ID!, $usernames: [String!]!) {
+      project(fullPath: $path) {
+        labels(includeAncestorGroups: true, first: 250) { nodes { id title } }
+      }
+      users(usernames: $usernames) { nodes { id username } }
+    }`, { path: projectPath, usernames: usernames ?? [] });
+    const labels = data.project?.labels?.nodes ?? [];
+    const users = data.users?.nodes ?? [];
+    const labelIds = (labelNames ?? []).map((name) => {
+        const label = labels.find((item) => item.title === name);
+        if (!label) {
+            throw new Error(`Label '${name}' not found in project ${projectPath}`);
+        }
+        return label.id;
+    });
+    const userIds = (usernames ?? []).map((username) => {
+        const user = users.find((item) => item.username === username);
+        if (!user) {
+            throw new Error(`User '${username}' not found`);
+        }
+        return user.id;
+    });
+    return { labelIds, userIds };
+}
+function normalizeGlobalId(value, typeName) {
+    return value.startsWith("gid://") ? value : `gid://gitlab/${typeName}/${value}`;
+}
+function toWorkItemGraphqlType(type) {
+    return WORK_ITEM_GRAPHQL_TYPES[type] ?? type.replace(/ /g, "_").toUpperCase();
+}
+function workItemTypeName(type) {
+    return WORK_ITEM_TYPE_NAMES[type] ?? "Issue";
+}
+function findWidget(widgets, typename) {
+    if (!Array.isArray(widgets)) {
+        return undefined;
+    }
+    return widgets.find((item) => typeof item === "object" && item !== null && item.__typename === typename);
+}
+async function getWorkItem(context, projectId, iid) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const data = await executeGraphqlData(context, `query($path: ID!, $iid: String!) {
+      namespace(fullPath: $path) {
+        workItem(iid: $iid) {
+          id
+          iid
+          title
+          state
+          description
+          webUrl
+          confidential
+          author { username }
+          createdAt
+          closedAt
+          workItemType { name }
+          widgets {
+            __typename
+            ... on WorkItemWidgetHierarchy {
+              hasChildren
+              hasParent
+              parent { id iid title webUrl workItemType { name } namespace { fullPath } }
+              children { nodes { id iid title state webUrl workItemType { name } namespace { fullPath } } }
+            }
+            ... on WorkItemWidgetStatus { status { id name category color iconName position } }
+            ... on WorkItemWidgetCustomFields {
+              customFieldValues {
+                __typename
+                customField { id name fieldType }
+                ... on WorkItemNumberFieldValue { value }
+                ... on WorkItemTextFieldValue { value }
+                ... on WorkItemSelectFieldValue { selectedOptions { id value } }
+              }
+            }
+            ... on WorkItemWidgetLabels { labels { nodes { id title color } } }
+            ... on WorkItemWidgetAssignees { assignees { nodes { id username name } } }
+            ... on WorkItemWidgetWeight { weight rolledUpWeight rolledUpCompletedWeight }
+            ... on WorkItemWidgetHealthStatus { healthStatus }
+            ... on WorkItemWidgetStartAndDueDate { startDate dueDate }
+            ... on WorkItemWidgetMilestone { milestone { id title } }
+            ... on WorkItemWidgetLinkedItems {
+              blocked
+              blockedByCount
+              blockingCount
+              linkedItems { nodes { linkType workItem { id iid title state webUrl workItemType { name } namespace { fullPath } } } }
+            }
+            ... on WorkItemWidgetTimeTracking { timeEstimate totalTimeSpent }
+            ... on WorkItemWidgetDevelopment {
+              willAutoCloseByMergeRequest
+              relatedBranches { nodes { name } }
+              relatedMergeRequests { nodes { iid title webUrl state sourceBranch } }
+              closingMergeRequests { nodes { mergeRequest { iid title webUrl state sourceBranch } } }
+              featureFlags { nodes { name active } }
+            }
+            ... on WorkItemWidgetIteration {
+              iteration { id title startDate dueDate webUrl iterationCadence { id title } }
+            }
+            ... on WorkItemWidgetProgress { progress }
+            ... on WorkItemWidgetColor { color textColor }
+          }
+        }
+      }
+    }`, { path: projectPath, iid: String(iid) });
+    const workItem = data.namespace?.workItem;
+    if (!workItem) {
+        throw new Error(`Work item #${iid} not found in project ${projectPath}`);
+    }
+    return flattenWorkItem(workItem);
+}
+function flattenWorkItem(workItem) {
+    const widgets = workItem.widgets ?? [];
+    const hierarchy = findWidget(widgets, "WorkItemWidgetHierarchy");
+    const status = findWidget(widgets, "WorkItemWidgetStatus");
+    const labels = findWidget(widgets, "WorkItemWidgetLabels");
+    const assignees = findWidget(widgets, "WorkItemWidgetAssignees");
+    const weight = findWidget(widgets, "WorkItemWidgetWeight");
+    const health = findWidget(widgets, "WorkItemWidgetHealthStatus");
+    const dates = findWidget(widgets, "WorkItemWidgetStartAndDueDate");
+    const milestone = findWidget(widgets, "WorkItemWidgetMilestone");
+    const linked = findWidget(widgets, "WorkItemWidgetLinkedItems");
+    const timeTracking = findWidget(widgets, "WorkItemWidgetTimeTracking");
+    const development = findWidget(widgets, "WorkItemWidgetDevelopment");
+    const customFields = findWidget(widgets, "WorkItemWidgetCustomFields");
+    const iteration = findWidget(widgets, "WorkItemWidgetIteration");
+    const progress = findWidget(widgets, "WorkItemWidgetProgress");
+    const color = findWidget(widgets, "WorkItemWidgetColor");
+    const result = {
+        id: workItem.id,
+        iid: workItem.iid,
+        title: workItem.title,
+        state: workItem.state,
+        type: workItem.workItemType?.name,
+        webUrl: workItem.webUrl
+    };
+    if (workItem.description)
+        result.description = workItem.description;
+    if (workItem.confidential)
+        result.confidential = true;
+    if (workItem.author?.username)
+        result.author = workItem.author.username;
+    if (workItem.createdAt)
+        result.createdAt = workItem.createdAt;
+    if (workItem.closedAt)
+        result.closedAt = workItem.closedAt;
+    if (status?.status) {
+        result.status = {
+            id: status.status.id,
+            name: status.status.name,
+            category: status.status.category
+        };
+    }
+    const labelNames = (labels?.labels?.nodes ?? []).map((item) => item.title);
+    if (labelNames.length > 0)
+        result.labels = labelNames;
+    const assigneeNames = (assignees?.assignees?.nodes ?? []).map((item) => item.username);
+    if (assigneeNames.length > 0)
+        result.assignees = assigneeNames;
+    if (weight?.weight != null) {
+        result.weight = weight.weight;
+        if (weight.rolledUpWeight != null)
+            result.rolledUpWeight = weight.rolledUpWeight;
+        if (weight.rolledUpCompletedWeight != null) {
+            result.rolledUpCompletedWeight = weight.rolledUpCompletedWeight;
+        }
+    }
+    if (health?.healthStatus)
+        result.healthStatus = health.healthStatus;
+    if (dates?.startDate)
+        result.startDate = dates.startDate;
+    if (dates?.dueDate)
+        result.dueDate = dates.dueDate;
+    if (milestone?.milestone)
+        result.milestone = milestone.milestone;
+    if (iteration?.iteration)
+        result.iteration = iteration.iteration;
+    if (progress?.progress != null)
+        result.progress = progress.progress;
+    if (color?.color)
+        result.color = color.color;
+    if (hierarchy?.parent) {
+        result.parent = {
+            iid: hierarchy.parent.iid,
+            title: hierarchy.parent.title,
+            type: hierarchy.parent.workItemType?.name,
+            project: hierarchy.parent.namespace?.fullPath,
+            webUrl: hierarchy.parent.webUrl
+        };
+    }
+    const children = hierarchy?.children?.nodes ?? [];
+    if (children.length > 0) {
+        result.children = children.map((item) => ({
+            iid: item.iid,
+            title: item.title,
+            state: item.state,
+            type: item.workItemType?.name,
+            project: item.namespace?.fullPath,
+            webUrl: item.webUrl
+        }));
+    }
+    if (linked?.blocked)
+        result.blocked = true;
+    if ((linked?.blockedByCount ?? 0) > 0)
+        result.blockedByCount = linked?.blockedByCount;
+    if ((linked?.blockingCount ?? 0) > 0)
+        result.blockingCount = linked?.blockingCount;
+    const linkedItems = linked?.linkedItems?.nodes ?? [];
+    if (linkedItems.length > 0) {
+        result.linkedItems = linkedItems.map((item) => ({
+            linkType: item.linkType,
+            iid: item.workItem?.iid,
+            title: item.workItem?.title,
+            state: item.workItem?.state,
+            type: item.workItem?.workItemType?.name,
+            project: item.workItem?.namespace?.fullPath,
+            webUrl: item.workItem?.webUrl
+        }));
+    }
+    if ((timeTracking?.timeEstimate ?? 0) > 0)
+        result.timeEstimate = timeTracking?.timeEstimate;
+    if ((timeTracking?.totalTimeSpent ?? 0) > 0) {
+        result.totalTimeSpent = timeTracking?.totalTimeSpent;
+    }
+    const relatedMergeRequests = development?.relatedMergeRequests?.nodes ?? [];
+    const closingMergeRequests = (development?.closingMergeRequests?.nodes ?? []).map((item) => item.mergeRequest);
+    const branches = development?.relatedBranches?.nodes ?? [];
+    const flags = development?.featureFlags?.nodes ?? [];
+    if (relatedMergeRequests.length > 0 ||
+        closingMergeRequests.length > 0 ||
+        branches.length > 0 ||
+        flags.length > 0) {
+        result.development = {};
+        if (relatedMergeRequests.length > 0) {
+            result.development.relatedMergeRequests = relatedMergeRequests;
+        }
+        if (closingMergeRequests.length > 0) {
+            result.development.closingMergeRequests = closingMergeRequests;
+        }
+        if (branches.length > 0) {
+            result.development.relatedBranches = branches.map((item) => item.name);
+        }
+        if (flags.length > 0)
+            result.development.featureFlags = flags;
+    }
+    const fieldValues = (customFields?.customFieldValues ?? []).filter((item) => item.value != null || item.selectedOptions != null);
+    if (fieldValues.length > 0) {
+        result.customFields = fieldValues.map((item) => ({
+            name: item.customField?.name,
+            type: item.customField?.fieldType,
+            value: item.value ?? item.selectedOptions ?? null
+        }));
+    }
+    return result;
+}
+async function listWorkItems(context, projectId, options) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const variables = {
+        path: projectPath,
+        first: options.first ?? 20,
+        types: options.types?.map(toWorkItemGraphqlType),
+        state: options.state,
+        search: options.search,
+        assigneeUsernames: options.assigneeUsernames,
+        labelName: options.labelNames,
+        after: options.after
+    };
+    const data = await executeGraphqlData(context, `query($path: ID!, $types: [IssueType!], $state: IssuableState, $search: String, $assigneeUsernames: [String!], $labelName: [String!], $first: Int, $after: String) {
+      project(fullPath: $path) {
+        workItems(types: $types, state: $state, search: $search, assigneeUsernames: $assigneeUsernames, labelName: $labelName, first: $first, after: $after) {
+          nodes {
+            id iid title state webUrl workItemType { name }
+            widgets {
+              __typename
+              ... on WorkItemWidgetStatus { status { id name category color } }
+              ... on WorkItemWidgetLabels { labels { nodes { title } } }
+              ... on WorkItemWidgetAssignees { assignees { nodes { username } } }
+              ... on WorkItemWidgetWeight { weight }
+              ... on WorkItemWidgetHealthStatus { healthStatus }
+              ... on WorkItemWidgetStartAndDueDate { startDate dueDate }
+              ... on WorkItemWidgetMilestone { milestone { id title } }
+            }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }`, variables);
+    const nodes = data.project?.workItems?.nodes ?? [];
+    return {
+        items: nodes.map(flattenWorkItemSummary),
+        pageInfo: data.project?.workItems?.pageInfo ?? {}
+    };
+}
+function flattenWorkItemSummary(workItem) {
+    const widgets = workItem.widgets ?? [];
+    const status = findWidget(widgets, "WorkItemWidgetStatus");
+    const labels = findWidget(widgets, "WorkItemWidgetLabels");
+    const assignees = findWidget(widgets, "WorkItemWidgetAssignees");
+    const weight = findWidget(widgets, "WorkItemWidgetWeight");
+    const health = findWidget(widgets, "WorkItemWidgetHealthStatus");
+    const dates = findWidget(widgets, "WorkItemWidgetStartAndDueDate");
+    const milestone = findWidget(widgets, "WorkItemWidgetMilestone");
+    const item = {
+        iid: workItem.iid,
+        title: workItem.title,
+        state: workItem.state,
+        type: workItem.workItemType?.name,
+        webUrl: workItem.webUrl
+    };
+    if (status?.status)
+        item.status = status.status.name;
+    const labelNames = (labels?.labels?.nodes ?? []).map((label) => label.title);
+    if (labelNames.length > 0)
+        item.labels = labelNames;
+    const assigneeNames = (assignees?.assignees?.nodes ?? []).map((assignee) => assignee.username);
+    if (assigneeNames.length > 0)
+        item.assignees = assigneeNames;
+    if (weight?.weight != null)
+        item.weight = weight.weight;
+    if (health?.healthStatus)
+        item.healthStatus = health.healthStatus;
+    if (dates?.startDate)
+        item.startDate = dates.startDate;
+    if (dates?.dueDate)
+        item.dueDate = dates.dueDate;
+    if (milestone?.milestone)
+        item.milestone = milestone.milestone.title;
+    return item;
+}
+async function createWorkItem(context, projectId, options) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const typeId = await resolveWorkItemTypeGid(context, projectPath, options.type ?? "issue");
+    const variableDefinitions = ["$projectPath: ID!", "$title: String!", "$typeId: WorkItemsTypeID!"];
+    const inputParts = ["namespacePath: $projectPath", "title: $title", "workItemTypeId: $typeId"];
+    const variables = {
+        projectPath,
+        title: options.title,
+        typeId
+    };
+    if (options.description !== undefined) {
+        variableDefinitions.push("$description: String!");
+        inputParts.push("descriptionWidget: { description: $description }");
+        variables.description = options.description;
+    }
+    const { labelIds, userIds } = await resolveNamesToIds(context, projectPath, options.labels, options.assigneeUsernames);
+    if (labelIds.length > 0) {
+        variableDefinitions.push("$labelIds: [LabelID!]!");
+        inputParts.push("labelsWidget: { labelIds: $labelIds }");
+        variables.labelIds = labelIds;
+    }
+    if (userIds.length > 0) {
+        variableDefinitions.push("$assigneeIds: [UserID!]!");
+        inputParts.push("assigneesWidget: { assigneeIds: $assigneeIds }");
+        variables.assigneeIds = userIds;
+    }
+    if (options.weight !== undefined) {
+        variableDefinitions.push("$weight: Int");
+        inputParts.push("weightWidget: { weight: $weight }");
+        variables.weight = options.weight;
+    }
+    if (options.parentIid !== undefined) {
+        const { workItemGid: parentId } = await resolveWorkItemGid(context, projectId, options.parentIid);
+        variableDefinitions.push("$parentId: WorkItemID");
+        inputParts.push("hierarchyWidget: { parentId: $parentId }");
+        variables.parentId = parentId;
+    }
+    if (options.healthStatus !== undefined) {
+        variableDefinitions.push("$healthStatus: HealthStatus");
+        inputParts.push("healthStatusWidget: { healthStatus: $healthStatus }");
+        variables.healthStatus = options.healthStatus;
+    }
+    appendDateWidget(variableDefinitions, inputParts, variables, options.startDate, options.dueDate);
+    if (options.milestoneId !== undefined) {
+        variableDefinitions.push("$milestoneId: MilestoneID");
+        inputParts.push("milestoneWidget: { milestoneId: $milestoneId }");
+        variables.milestoneId = normalizeGlobalId(options.milestoneId, "Milestone");
+    }
+    if (options.iterationId !== undefined) {
+        variableDefinitions.push("$iterationId: IterationID");
+        inputParts.push("iterationWidget: { iterationId: $iterationId }");
+        variables.iterationId = normalizeGlobalId(options.iterationId, "Iteration");
+    }
+    if (options.confidential !== undefined) {
+        variableDefinitions.push("$confidential: Boolean");
+        inputParts.push("confidential: $confidential");
+        variables.confidential = options.confidential;
+    }
+    const data = await executeGraphqlData(context, `mutation(${variableDefinitions.join(", ")}) {
+      workItemCreate(input: { ${inputParts.join(", ")} }) {
+        workItem { id iid title webUrl workItemType { name } }
+        errors
+      }
+    }`, variables);
+    assertNoGraphqlMutationErrors(data.workItemCreate?.errors, "Failed to create work item");
+    const workItem = data.workItemCreate.workItem;
+    return {
+        id: workItem?.id,
+        iid: workItem?.iid,
+        title: workItem?.title,
+        type: workItem?.workItemType?.name,
+        webUrl: workItem?.webUrl
+    };
+}
+function appendDateWidget(variableDefinitions, inputParts, variables, startDate, dueDate) {
+    if (startDate === undefined && dueDate === undefined) {
+        return;
+    }
+    const dateParts = [];
+    if (startDate !== undefined) {
+        variableDefinitions.push("$startDate: Date");
+        dateParts.push("startDate: $startDate");
+        variables.startDate = startDate;
+    }
+    if (dueDate !== undefined) {
+        variableDefinitions.push("$dueDate: Date");
+        dateParts.push("dueDate: $dueDate");
+        variables.dueDate = dueDate;
+    }
+    inputParts.push(`startAndDueDateWidget: { ${dateParts.join(", ")} }`);
+}
+async function updateWorkItem(context, projectId, iid, options) {
+    const { workItemGid, projectPath } = await resolveWorkItemGid(context, projectId, iid);
+    const variableDefinitions = ["$id: WorkItemID!"];
+    const inputParts = ["id: $id"];
+    const variables = { id: workItemGid };
+    if (options.title !== undefined) {
+        variableDefinitions.push("$title: String");
+        inputParts.push("title: $title");
+        variables.title = options.title;
+    }
+    if (options.description !== undefined) {
+        variableDefinitions.push("$description: String!");
+        inputParts.push("descriptionWidget: { description: $description }");
+        variables.description = options.description;
+    }
+    const allLabelNames = [...(options.addLabels ?? []), ...(options.removeLabels ?? [])];
+    const needsNameResolution = allLabelNames.length > 0 || !!options.assigneeUsernames?.length;
+    const { labelIds, userIds } = needsNameResolution
+        ? await resolveNamesToIds(context, projectPath, allLabelNames.length > 0 ? allLabelNames : undefined, options.assigneeUsernames)
+        : { labelIds: [], userIds: [] };
+    if (options.addLabels || options.removeLabels) {
+        const labelParts = [];
+        if (options.addLabels && options.addLabels.length > 0) {
+            variableDefinitions.push("$addLabelIds: [LabelID!]");
+            labelParts.push("addLabelIds: $addLabelIds");
+            variables.addLabelIds = labelIds.slice(0, options.addLabels.length);
+        }
+        if (options.removeLabels && options.removeLabels.length > 0) {
+            variableDefinitions.push("$removeLabelIds: [LabelID!]");
+            labelParts.push("removeLabelIds: $removeLabelIds");
+            variables.removeLabelIds = labelIds.slice(options.addLabels?.length ?? 0);
+        }
+        if (labelParts.length > 0)
+            inputParts.push(`labelsWidget: { ${labelParts.join(", ")} }`);
+    }
+    if (userIds.length > 0) {
+        variableDefinitions.push("$assigneeIds: [UserID!]!");
+        inputParts.push("assigneesWidget: { assigneeIds: $assigneeIds }");
+        variables.assigneeIds = userIds;
+    }
+    if (options.stateEvent !== undefined) {
+        variableDefinitions.push("$stateEvent: WorkItemStateEvent");
+        inputParts.push("stateEvent: $stateEvent");
+        variables.stateEvent = options.stateEvent === "close" ? "CLOSE" : "REOPEN";
+    }
+    if (options.weight !== undefined) {
+        variableDefinitions.push("$weight: Int");
+        inputParts.push("weightWidget: { weight: $weight }");
+        variables.weight = options.weight;
+    }
+    if (options.status !== undefined) {
+        variableDefinitions.push("$status: WorkItemsStatusesStatusID");
+        inputParts.push("statusWidget: { status: $status }");
+        variables.status = options.status;
+    }
+    if (options.healthStatus !== undefined) {
+        variableDefinitions.push("$healthStatus: HealthStatus");
+        inputParts.push("healthStatusWidget: { healthStatus: $healthStatus }");
+        variables.healthStatus = options.healthStatus;
+    }
+    appendDateWidget(variableDefinitions, inputParts, variables, options.startDate, options.dueDate);
+    if (options.milestoneId !== undefined) {
+        variableDefinitions.push("$milestoneId: MilestoneID");
+        inputParts.push("milestoneWidget: { milestoneId: $milestoneId }");
+        variables.milestoneId = normalizeGlobalId(options.milestoneId, "Milestone");
+    }
+    if (options.iterationId !== undefined) {
+        variableDefinitions.push("$iterationId: IterationID");
+        inputParts.push("iterationWidget: { iterationId: $iterationId }");
+        variables.iterationId = normalizeGlobalId(options.iterationId, "Iteration");
+    }
+    if (options.confidential !== undefined) {
+        variableDefinitions.push("$confidential: Boolean");
+        inputParts.push("confidential: $confidential");
+        variables.confidential = options.confidential;
+    }
+    if (options.customFields && options.customFields.length > 0) {
+        variableDefinitions.push("$customFieldsWidget: [WorkItemWidgetCustomFieldValueInputType!]");
+        inputParts.push("customFieldsWidget: $customFieldsWidget");
+        variables.customFieldsWidget = options.customFields.map((field) => ({
+            customFieldId: normalizeGlobalId(field.custom_field_id, "IssuablesCustomField"),
+            textValue: field.text_value,
+            numberValue: field.number_value,
+            selectedOptionIds: field.selected_option_ids,
+            dateValue: field.date_value
+        }));
+    }
+    if (options.removeParent) {
+        inputParts.push("hierarchyWidget: { parentId: null }");
+    }
+    else if (options.parentIid !== undefined) {
+        const parentProjectId = options.parentProjectId ?? projectId;
+        const { workItemGid: parentId } = await resolveWorkItemGid(context, parentProjectId, options.parentIid);
+        variableDefinitions.push("$parentId: WorkItemID");
+        inputParts.push("hierarchyWidget: { parentId: $parentId }");
+        variables.parentId = parentId;
+    }
+    const data = await executeGraphqlData(context, `mutation(${variableDefinitions.join(", ")}) {
+      workItemUpdate(input: { ${inputParts.join(", ")} }) {
+        workItem {
+          id iid title state webUrl workItemType { name }
+          widgets {
+            __typename
+            ... on WorkItemWidgetStatus { status { id name category color } }
+            ... on WorkItemWidgetLabels { labels { nodes { title } } }
+            ... on WorkItemWidgetAssignees { assignees { nodes { username } } }
+            ... on WorkItemWidgetWeight { weight }
+            ... on WorkItemWidgetHierarchy { parent { id title workItemType { name } } }
+            ... on WorkItemWidgetHealthStatus { healthStatus }
+            ... on WorkItemWidgetStartAndDueDate { startDate dueDate }
+            ... on WorkItemWidgetMilestone { milestone { id title } }
+          }
+        }
+        errors
+      }
+    }`, variables);
+    assertNoGraphqlMutationErrors(data.workItemUpdate?.errors, "Failed to update work item");
+    await updateWorkItemRelationships(context, workItemGid, options);
+    if (options.severity !== undefined) {
+        await updateIncidentSeverity(context, projectPath, iid, options.severity);
+    }
+    if (options.escalationStatus !== undefined) {
+        await updateIncidentEscalationStatus(context, projectPath, iid, options.escalationStatus);
+    }
+    const workItem = data.workItemUpdate.workItem ?? {};
+    return {
+        ...flattenWorkItemSummary(workItem),
+        id: workItem.id,
+        children_added: options.childrenToAdd?.length ?? 0,
+        children_removed: options.childrenToRemove?.length ?? 0,
+        linked_items_added: options.linkedItemsToAdd?.length ?? 0,
+        linked_items_removed: options.linkedItemsToRemove?.length ?? 0,
+        ...(options.severity !== undefined ? { severity: options.severity } : {}),
+        ...(options.escalationStatus !== undefined
+            ? { escalation_status: options.escalationStatus }
+            : {})
+    };
+}
+async function updateWorkItemRelationships(context, workItemGid, options) {
+    if (options.childrenToAdd && options.childrenToAdd.length > 0) {
+        const childIds = [];
+        for (const child of options.childrenToAdd) {
+            const { workItemGid: childId } = await resolveWorkItemGid(context, child.project_id, child.iid);
+            childIds.push(childId);
+        }
+        const data = await executeGraphqlData(context, `mutation($id: WorkItemID!, $childrenIds: [WorkItemID!]!) {
+        workItemUpdate(input: { id: $id, hierarchyWidget: { childrenIds: $childrenIds } }) {
+          errors
+        }
+      }`, { id: workItemGid, childrenIds: childIds });
+        assertNoGraphqlMutationErrors(data.workItemUpdate?.errors, "Failed to add children");
+    }
+    if (options.childrenToRemove) {
+        for (const child of options.childrenToRemove) {
+            await removeWorkItemParent(context, child.project_id, child.iid);
+        }
+    }
+    if (options.linkedItemsToAdd && options.linkedItemsToAdd.length > 0) {
+        const grouped = {};
+        for (const item of options.linkedItemsToAdd) {
+            const linkType = item.link_type ?? "RELATED";
+            const { workItemGid: targetId } = await resolveWorkItemGid(context, item.project_id, item.iid);
+            grouped[linkType] = [...(grouped[linkType] ?? []), targetId];
+        }
+        for (const [linkType, targetIds] of Object.entries(grouped)) {
+            const data = await executeGraphqlData(context, `mutation($id: WorkItemID!, $workItemsIds: [WorkItemID!]!, $linkType: WorkItemRelatedLinkType!) {
+          workItemAddLinkedItems(input: { id: $id, workItemsIds: $workItemsIds, linkType: $linkType }) {
+            errors
+          }
+        }`, { id: workItemGid, workItemsIds: targetIds, linkType });
+            assertNoGraphqlMutationErrors(data.workItemAddLinkedItems?.errors, "Failed to add linked items");
+        }
+    }
+    if (options.linkedItemsToRemove && options.linkedItemsToRemove.length > 0) {
+        const targetIds = [];
+        for (const item of options.linkedItemsToRemove) {
+            const { workItemGid: targetId } = await resolveWorkItemGid(context, item.project_id, item.iid);
+            targetIds.push(targetId);
+        }
+        const data = await executeGraphqlData(context, `mutation($id: WorkItemID!, $workItemsIds: [WorkItemID!]!) {
+        workItemRemoveLinkedItems(input: { id: $id, workItemsIds: $workItemsIds }) { errors }
+      }`, { id: workItemGid, workItemsIds: targetIds });
+        assertNoGraphqlMutationErrors(data.workItemRemoveLinkedItems?.errors, "Failed to remove linked items");
+    }
+}
+async function removeWorkItemParent(context, projectId, iid) {
+    const { workItemGid } = await resolveWorkItemGid(context, projectId, iid);
+    const data = await executeGraphqlData(context, `mutation($id: WorkItemID!) {
+      workItemUpdate(input: { id: $id, hierarchyWidget: { parentId: null } }) { errors }
+    }`, { id: workItemGid });
+    assertNoGraphqlMutationErrors(data.workItemUpdate?.errors, "Failed to remove parent");
+}
+async function convertWorkItemType(context, projectId, iid, newType) {
+    const { workItemGid, projectPath } = await resolveWorkItemGid(context, projectId, iid);
+    const typeId = await resolveWorkItemTypeGid(context, projectPath, newType);
+    const data = await executeGraphqlData(context, `mutation($id: WorkItemID!, $typeId: WorkItemsTypeID!) {
+      workItemConvert(input: { id: $id, workItemTypeId: $typeId }) {
+        workItem { id workItemType { name } }
+        errors
+      }
+    }`, { id: workItemGid, typeId });
+    assertNoGraphqlMutationErrors(data.workItemConvert?.errors, "Conversion failed");
+    return {
+        id: data.workItemConvert.workItem?.id,
+        type: data.workItemConvert.workItem?.workItemType?.name
+    };
+}
+async function listWorkItemStatuses(context, projectId, type) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const typeName = workItemTypeName(type);
+    const data = await executeGraphqlData(context, `query($path: ID!, $typeName: IssueType) {
+      namespace(fullPath: $path) {
+        workItemTypes(name: $typeName) {
+          nodes {
+            id
+            name
+            supportedConversionTypes { id name }
+            widgetDefinitions {
+              __typename
+              ... on WorkItemWidgetDefinitionStatus {
+                allowedStatuses { id name iconName color position }
+              }
+              ... on WorkItemWidgetDefinitionHierarchy {
+                allowedChildTypes { nodes { id name } }
+                allowedParentTypes { nodes { id name } }
+              }
+            }
+          }
+        }
+      }
+    }`, { path: projectPath, typeName: typeName.replace(/ /g, "_").toUpperCase() });
+    const typeNode = data.namespace?.workItemTypes?.nodes?.[0];
+    if (!typeNode) {
+        throw new Error(`Work item type '${typeName}' not found in project ${projectPath}`);
+    }
+    const statusWidget = typeNode.widgetDefinitions?.find((widget) => widget.__typename === "WorkItemWidgetDefinitionStatus");
+    const hierarchyWidget = typeNode.widgetDefinitions?.find((widget) => widget.__typename === "WorkItemWidgetDefinitionHierarchy");
+    return {
+        work_item_type: typeNode.name,
+        statuses_available: (statusWidget?.allowedStatuses ?? []).length > 0,
+        statuses: statusWidget?.allowedStatuses ?? [],
+        supported_conversion_types: (typeNode.supportedConversionTypes ?? []).map((item) => item.name),
+        allowed_child_types: (hierarchyWidget?.allowedChildTypes?.nodes ?? []).map((item) => item.name),
+        allowed_parent_types: (hierarchyWidget?.allowedParentTypes?.nodes ?? []).map((item) => item.name)
+    };
+}
+async function listCustomFieldDefinitions(context, projectId, type) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const typeName = workItemTypeName(type);
+    const data = await executeGraphqlData(context, `query($path: ID!, $typeName: IssueType) {
+      namespace(fullPath: $path) {
+        workItemTypes(name: $typeName) {
+          nodes {
+            id
+            name
+            widgetDefinitions {
+              __typename
+              ... on WorkItemWidgetDefinitionCustomFields {
+                customFieldValues {
+                  customField {
+                    id
+                    name
+                    fieldType
+                    selectOptions { id value }
+                    workItemTypes { id name }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }`, { path: projectPath, typeName: typeName.replace(/ /g, "_").toUpperCase() });
+    const typeNode = data.namespace?.workItemTypes?.nodes?.[0];
+    if (!typeNode) {
+        throw new Error(`Work item type '${typeName}' not found in project ${projectPath}`);
+    }
+    const widget = typeNode.widgetDefinitions?.find((item) => item.__typename === "WorkItemWidgetDefinitionCustomFields");
+    return {
+        work_item_type: typeNode.name,
+        custom_fields: (widget?.customFieldValues ?? []).map((item) => {
+            const field = item.customField ?? {};
+            return {
+                id: field.id,
+                name: field.name,
+                type: field.fieldType,
+                ...(field.selectOptions?.length ? { selectOptions: field.selectOptions } : {}),
+                ...(field.workItemTypes?.length
+                    ? { workItemTypes: field.workItemTypes.map((workItemType) => workItemType.name) }
+                    : {})
+            };
+        })
+    };
+}
+async function moveWorkItem(context, projectId, iid, targetProjectId) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const targetProjectPath = await resolveProjectPathForWorkItem(context, targetProjectId);
+    const data = await executeGraphqlData(context, `mutation($projectPath: ID!, $iid: String!, $targetProjectPath: ID!) {
+      issueMove(input: { projectPath: $projectPath, iid: $iid, targetProjectPath: $targetProjectPath }) {
+        issue { id iid webUrl }
+        errors
+      }
+    }`, { projectPath, iid: String(iid), targetProjectPath });
+    assertNoGraphqlMutationErrors(data.issueMove?.errors, "Failed to move work item");
+    return data.issueMove.issue;
+}
+async function listWorkItemNotes(context, projectId, iid, options) {
+    const projectPath = await resolveProjectPathForWorkItem(context, projectId);
+    const data = await executeGraphqlData(context, `query($path: ID!, $iid: String!, $pageSize: Int, $after: String, $sort: WorkItemDiscussionsSort) {
+      namespace(fullPath: $path) {
+        workItem(iid: $iid) {
+          id
+          widgets(onlyTypes: [NOTES]) {
+            ... on WorkItemWidgetNotes {
+              discussionLocked
+              discussions(first: $pageSize, after: $after, filter: ALL_NOTES, sort: $sort) {
+                pageInfo { hasNextPage endCursor }
+                nodes {
+                  id
+                  resolved
+                  resolvable
+                  notes {
+                    nodes {
+                      id
+                      body
+                      system
+                      internal
+                      createdAt
+                      lastEditedAt
+                      author { username }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }`, {
+        path: projectPath,
+        iid: String(iid),
+        pageSize: options.pageSize ?? 20,
+        after: options.after ?? null,
+        sort: options.sort ?? "CREATED_ASC"
+    });
+    const workItem = data.namespace?.workItem;
+    if (!workItem) {
+        throw new Error(`Work item #${iid} not found in project ${projectPath}`);
+    }
+    const notesWidget = (workItem.widgets ?? []).find((widget) => widget.discussions);
+    const discussions = notesWidget?.discussions;
+    return {
+        discussions: (discussions?.nodes ?? []).map((discussion) => ({
+            id: discussion.id,
+            resolved: discussion.resolved,
+            resolvable: discussion.resolvable,
+            notes: (discussion.notes?.nodes ?? []).map((note) => ({
+                id: note.id,
+                author: note.author?.username,
+                body: note.body,
+                createdAt: note.createdAt,
+                ...(note.system ? { system: true } : {}),
+                ...(note.internal ? { internal: true } : {}),
+                ...(note.lastEditedAt ? { lastEditedAt: note.lastEditedAt } : {})
+            }))
+        })),
+        pageInfo: discussions?.pageInfo ?? {}
+    };
+}
+async function resolveWorkItemNoteAwardableId(context, projectId, iid, noteId) {
+    let after;
+    for (let page = 0; page < 100; page += 1) {
+        const result = (await listWorkItemNotes(context, projectId, iid, {
+            pageSize: 100,
+            after,
+            sort: "CREATED_ASC"
+        }));
+        const found = (result.discussions ?? []).some((discussion) => (discussion.notes ?? []).some((note) => note.id === noteId));
+        if (found) {
+            return noteId;
+        }
+        if (result.pageInfo?.hasNextPage !== true || typeof result.pageInfo.endCursor !== "string") {
+            break;
+        }
+        after = result.pageInfo.endCursor;
+    }
+    throw new Error(`Note '${noteId}' was not found on work item #${iid} in project ${projectId}`);
+}
+async function createWorkItemNote(context, projectId, iid, body, options) {
+    const { workItemGid } = await resolveWorkItemGid(context, projectId, iid);
+    const variableDefinitions = ["$noteableId: NoteableID!", "$body: String!"];
+    const inputParts = ["noteableId: $noteableId", "body: $body"];
+    const variables = { noteableId: workItemGid, body };
+    if (options.internal) {
+        variableDefinitions.push("$internal: Boolean");
+        inputParts.push("internal: $internal");
+        variables.internal = true;
+    }
+    if (options.discussionId) {
+        variableDefinitions.push("$discussionId: DiscussionID");
+        inputParts.push("discussionId: $discussionId");
+        variables.discussionId = options.discussionId;
+    }
+    const data = await executeGraphqlData(context, `mutation(${variableDefinitions.join(", ")}) {
+      createNote(input: { ${inputParts.join(", ")} }) {
+        note { id body discussion { id } }
+        errors
+      }
+    }`, variables);
+    assertNoGraphqlMutationErrors(data.createNote?.errors, "Failed to create note");
+    return data.createNote.note;
+}
+async function addGraphqlAwardEmoji(context, awardableId, name) {
+    const data = await executeGraphqlData(context, `mutation($awardableId: AwardableID!, $name: String!) {
+      awardEmojiAdd(input: { awardableId: $awardableId, name: $name }) {
+        awardEmoji { name user { username } }
+        errors
+      }
+    }`, { awardableId, name });
+    assertNoGraphqlMutationErrors(data.awardEmojiAdd?.errors, "Failed to add emoji reaction");
+    return data.awardEmojiAdd.awardEmoji;
+}
+async function listGraphqlAwardEmoji(context, awardableId) {
+    const data = await executeGraphqlData(context, `query($id: AwardableID!) {
+      awardable(id: $id) {
+        awardEmoji { nodes { name user { username } } }
+      }
+    }`, { id: awardableId });
+    return data.awardable?.awardEmoji?.nodes ?? [];
+}
+async function removeGraphqlAwardEmoji(context, awardableId, name) {
+    const data = await executeGraphqlData(context, `mutation($awardableId: AwardableID!, $name: String!) {
+      awardEmojiRemove(input: { awardableId: $awardableId, name: $name }) {
+        awardEmoji { name }
+        errors
+      }
+    }`, { awardableId, name });
+    assertNoGraphqlMutationErrors(data.awardEmojiRemove?.errors, "Failed to remove emoji reaction");
+    return data.awardEmojiRemove.awardEmoji ?? { status: "success" };
+}
+async function getTimelineEvents(context, projectId, incidentIid) {
+    const { workItemGid, projectPath } = await resolveWorkItemGid(context, projectId, incidentIid);
+    const incidentId = workItemGid.replace("/WorkItem/", "/Issue/");
+    const data = await executeGraphqlData(context, `query($fullPath: ID!, $incidentId: IssueID!) {
+      project(fullPath: $fullPath) {
+        incidentManagementTimelineEvents(incidentId: $incidentId) {
+          nodes {
+            id
+            note
+            noteHtml
+            action
+            occurredAt
+            createdAt
+            timelineEventTags { nodes { id name } }
+          }
+        }
+      }
+    }`, { fullPath: projectPath, incidentId });
+    return (data.project?.incidentManagementTimelineEvents?.nodes ?? []).map((event) => ({
+        id: event.id,
+        note: event.note,
+        action: event.action,
+        occurredAt: event.occurredAt,
+        createdAt: event.createdAt,
+        ...(event.noteHtml ? { noteHtml: event.noteHtml } : {}),
+        ...(event.timelineEventTags?.nodes?.length
+            ? { tags: event.timelineEventTags.nodes.map((tag) => tag.name) }
+            : {})
+    }));
+}
+async function createTimelineEvent(context, projectId, incidentIid, note, occurredAt, tagNames) {
+    const { workItemGid } = await resolveWorkItemGid(context, projectId, incidentIid);
+    const incidentId = workItemGid.replace("/WorkItem/", "/Issue/");
+    const input = { incidentId, note, occurredAt };
+    if (tagNames && tagNames.length > 0) {
+        input.timelineEventTagNames = tagNames;
+    }
+    const data = await executeGraphqlData(context, `mutation CreateTimelineEvent($input: TimelineEventCreateInput!) {
+      timelineEventCreate(input: $input) {
+        timelineEvent {
+          id
+          note
+          noteHtml
+          action
+          occurredAt
+          createdAt
+          timelineEventTags { nodes { id name } }
+        }
+        errors
+      }
+    }`, { input });
+    assertNoGraphqlMutationErrors(data.timelineEventCreate?.errors, "Failed to create timeline event");
+    return data.timelineEventCreate.timelineEvent;
+}
+async function updateIncidentSeverity(context, projectPath, incidentIid, severity) {
+    const data = await executeGraphqlData(context, `mutation($projectPath: ID!, $severity: IssuableSeverity!, $iid: String!) {
+      issueSetSeverity(input: { iid: $iid, severity: $severity, projectPath: $projectPath }) {
+        errors
+      }
+    }`, { projectPath, severity, iid: String(incidentIid) });
+    assertNoGraphqlMutationErrors(data.issueSetSeverity?.errors, "Failed to set severity");
+}
+async function updateIncidentEscalationStatus(context, projectPath, incidentIid, status) {
+    const data = await executeGraphqlData(context, `mutation($projectPath: ID!, $status: IssueEscalationStatus!, $iid: String!) {
+      issueSetEscalationStatus(input: { projectPath: $projectPath, status: $status, iid: $iid }) {
+        errors
+      }
+    }`, { projectPath, status, iid: String(incidentIid) });
+    assertNoGraphqlMutationErrors(data.issueSetEscalationStatus?.errors, "Failed to set escalation status");
+}
+function assertNoGraphqlMutationErrors(errors, prefix) {
+    if (errors && errors.length > 0) {
+        throw new Error(`${prefix}: ${errors.join(", ")}`);
+    }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
 export function containsGraphqlMutation(query) {
     if (!query.trim()) {
         return false;
@@ -2459,7 +4804,25 @@ export function shouldDisableGraphqlTools(allowedProjectIds, allowGraphqlWithPro
 function isGraphqlToolName(name) {
     return (name === "gitlab_execute_graphql_query" ||
         name === "gitlab_execute_graphql_mutation" ||
-        name === "gitlab_execute_graphql");
+        name === "gitlab_execute_graphql" ||
+        name === "gitlab_get_work_item" ||
+        name === "gitlab_list_work_items" ||
+        name === "gitlab_create_work_item" ||
+        name === "gitlab_update_work_item" ||
+        name === "gitlab_convert_work_item_type" ||
+        name === "gitlab_list_work_item_statuses" ||
+        name === "gitlab_list_custom_field_definitions" ||
+        name === "gitlab_move_work_item" ||
+        name === "gitlab_list_work_item_notes" ||
+        name === "gitlab_create_work_item_note" ||
+        name === "gitlab_list_work_item_emoji_reactions" ||
+        name === "gitlab_list_work_item_note_emoji_reactions" ||
+        name === "gitlab_create_work_item_emoji_reaction" ||
+        name === "gitlab_delete_work_item_emoji_reaction" ||
+        name === "gitlab_create_work_item_note_emoji_reaction" ||
+        name === "gitlab_delete_work_item_note_emoji_reaction" ||
+        name === "gitlab_get_timeline_events" ||
+        name === "gitlab_create_timeline_event");
 }
 function resolveProjectId(args, context, required) {
     const fromArgs = getOptionalString(args, "project_id");
@@ -2481,6 +4844,69 @@ function resolveProjectId(args, context, required) {
     }
     return fromArgs ?? "";
 }
+async function withCiLintHttpDiagnostics(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const lintResult = toCiLintHttpDiagnosticResult(error);
+        if (lintResult) {
+            return lintResult;
+        }
+        throw error;
+    }
+}
+function toCiLintHttpDiagnosticResult(error) {
+    if (!(error instanceof GitLabApiError) || error.status !== 400) {
+        return undefined;
+    }
+    const details = redactSensitive(error.details);
+    const errors = extractCiLintMessages(details);
+    if (errors.length === 0 || !hasCiLintDiagnosticSignal(details, errors)) {
+        return undefined;
+    }
+    const result = typeof details === "object" && details !== null && !Array.isArray(details)
+        ? { ...details }
+        : {};
+    return {
+        ...result,
+        valid: false,
+        errors,
+        warnings: Array.isArray(result.warnings) ? result.warnings : [],
+        status: error.status
+    };
+}
+function extractCiLintMessages(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => extractCiLintMessages(item));
+    }
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+    const record = value;
+    const messages = [];
+    for (const key of ["errors", "message", "error"]) {
+        messages.push(...extractCiLintMessages(record[key]));
+    }
+    return [...new Set(messages.map((item) => item.trim()).filter((item) => item.length > 0))];
+}
+function hasCiLintDiagnosticSignal(details, messages) {
+    if (typeof details === "object" && details !== null && !Array.isArray(details)) {
+        const record = details;
+        if (record.valid === false ||
+            record.status === "invalid" ||
+            hasNonEmptyCiLintErrorsArray(record)) {
+            return true;
+        }
+    }
+    return messages.some((message) => /gitlab ci configuration is invalid|jobs config|ci config|config should contain/i.test(message));
+}
+function hasNonEmptyCiLintErrorsArray(record) {
+    return Array.isArray(record.errors) && extractCiLintMessages(record.errors).length > 0;
+}
 function toToolError(error, context) {
     const detailMode = context?.env.GITLAB_ERROR_DETAIL_MODE ?? "full";
     if (error instanceof GitLabApiError) {
@@ -2542,6 +4968,20 @@ function toStructuredContent(value) {
         value
     };
 }
+function maybeDecodeRepositoryFileContents(value, shouldDecode) {
+    if (!shouldDecode || typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    const file = value;
+    if (file.encoding !== "base64" || typeof file.content !== "string") {
+        return value;
+    }
+    return {
+        ...file,
+        content: Buffer.from(file.content, "base64").toString("utf8"),
+        encoding: "utf8"
+    };
+}
 function omit(args, keys) {
     const result = {};
     for (const [key, value] of Object.entries(args)) {
@@ -2580,6 +5020,88 @@ function toCsvValue(value) {
     }
     return undefined;
 }
+async function resolveMergeRequestIid(args, context, projectId, options) {
+    const mergeRequestIid = getOptionalString(args, "merge_request_iid");
+    if (mergeRequestIid) {
+        return mergeRequestIid;
+    }
+    const sourceBranch = getOptionalString(args, "source_branch");
+    if (!sourceBranch) {
+        throw new Error("Either merge_request_iid or source_branch must be provided");
+    }
+    const candidates = await context.gitlab.listMergeRequests(projectId, {
+        query: {
+            source_branch: sourceBranch,
+            per_page: 100,
+            page: 1
+        }
+    });
+    const match = pickMergeRequestForSourceBranch(candidates, sourceBranch, options);
+    return getMergeRequestIid(match);
+}
+function extractMergeRequestChanges(value) {
+    if (typeof value !== "object" || value === null || !("changes" in value)) {
+        return [];
+    }
+    const changes = value.changes;
+    return extractMergeRequestDiffRecords(changes);
+}
+function extractMergeRequestDiffRecords(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "object" && item !== null);
+}
+function filterChangedFiles(files, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return files;
+    }
+    const regexes = patterns.map((pattern) => new RegExp(pattern));
+    return files.filter((file) => {
+        const paths = [file.new_path, file.old_path].filter((value) => typeof value === "string");
+        return !regexes.some((regex) => paths.some((filePath) => regex.test(filePath)));
+    });
+}
+function resolveWebhookScope(args) {
+    const projectId = getOptionalString(args, "project_id");
+    const groupId = getOptionalString(args, "group_id");
+    if ((projectId ? 1 : 0) + (groupId ? 1 : 0) !== 1) {
+        throw new Error("Provide exactly one of project_id or group_id");
+    }
+    return projectId ? { projectId } : { groupId };
+}
+function summarizeWebhookEvents(events) {
+    return events.map((event) => ({
+        id: event.id,
+        url: event.url,
+        trigger: event.trigger,
+        response_status: event.response_status,
+        execution_duration: event.execution_duration
+    }));
+}
+async function findWebhookEvent(context, scope, hookId, eventId, page) {
+    const perPage = 20;
+    const pages = page ? [page] : Array.from({ length: 25 }, (_value, index) => index + 1);
+    for (const currentPage of pages) {
+        const events = extractRecords(await context.gitlab.listWebhookEvents(scope, hookId, {
+            query: { page: currentPage, per_page: perPage }
+        }));
+        const match = events.find((event) => String(event.id) === eventId);
+        if (match) {
+            return match;
+        }
+        if (events.length < perPage) {
+            break;
+        }
+    }
+    return undefined;
+}
+function extractRecords(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "object" && item !== null);
+}
 function pickMergeRequestForSourceBranch(value, sourceBranch, options) {
     const matches = extractMergeRequestRecords(value).filter((item) => {
         const candidateBranch = item.source_branch;
@@ -2625,6 +5147,122 @@ function getMergeRequestIid(mergeRequest) {
     }
     throw new Error("Matched merge request is missing a valid iid");
 }
+async function getDetailedMergeRequestFromMatch(projectId, mergeRequest, context) {
+    if (typeof context.gitlab.getMergeRequest !== "function") {
+        return mergeRequest;
+    }
+    return context.gitlab.getMergeRequest(projectId, getMergeRequestIid(mergeRequest));
+}
+async function withMergeRequestSummaries(projectId, mergeRequest, context) {
+    if (typeof mergeRequest !== "object" || mergeRequest === null || Array.isArray(mergeRequest)) {
+        return mergeRequest;
+    }
+    const record = mergeRequest;
+    const [commitAdditionSummary, approvalSummary] = await Promise.all([
+        buildMergeRequestCommitAdditionSummary(projectId, record, context),
+        buildMergeRequestApprovalSummary(projectId, record, context)
+    ]);
+    return {
+        ...record,
+        commit_addition_summary: commitAdditionSummary,
+        approval_summary: approvalSummary
+    };
+}
+async function buildMergeRequestCommitAdditionSummary(projectId, mergeRequest, context) {
+    const targetBranch = typeof mergeRequest.target_branch === "string" ? mergeRequest.target_branch : null;
+    try {
+        const sourceCommitCount = await context.gitlab.countMergeRequestCommits(projectId, getMergeRequestIid(mergeRequest));
+        const project = (await context.gitlab.getProject(projectId));
+        const mergeMethod = typeof project.merge_method === "string" ? project.merge_method : null;
+        const mergeCommitCount = estimateMergeCommitCount(mergeMethod, sourceCommitCount);
+        const summary = targetBranch && mergeCommitCount !== null
+            ? `${sourceCommitCount} commits and ${mergeCommitCount} merge commit${mergeCommitCount === 1 ? "" : "s"} will be added to ${targetBranch}.`
+            : null;
+        return {
+            target_branch: targetBranch,
+            source_commits_count: sourceCommitCount,
+            merge_method: mergeMethod,
+            merge_commit_count: mergeCommitCount,
+            summary
+        };
+    }
+    catch (error) {
+        return {
+            target_branch: targetBranch,
+            source_commits_count: null,
+            merge_method: null,
+            merge_commit_count: null,
+            summary: null,
+            unavailable_reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function estimateMergeCommitCount(mergeMethod, sourceCommitCount) {
+    if (sourceCommitCount === 0) {
+        return 0;
+    }
+    if (mergeMethod === "merge") {
+        return 1;
+    }
+    if (mergeMethod === "ff" || mergeMethod === "rebase_merge") {
+        return 0;
+    }
+    return null;
+}
+async function buildMergeRequestApprovalSummary(projectId, mergeRequest, context) {
+    try {
+        const approvalState = (await context.gitlab.getMergeRequestApprovalState(projectId, getMergeRequestIid(mergeRequest)));
+        const approvedBy = extractRecords(approvalState.approved_by);
+        const approvedByUsernames = getApprovalUsernames(approvalState, approvedBy);
+        const rules = extractRecords(approvalState.rules);
+        return {
+            approved: typeof approvalState.approved === "boolean"
+                ? approvalState.approved
+                : inferMergeRequestApproved(rules),
+            user_has_approved: typeof approvalState.user_has_approved === "boolean"
+                ? approvalState.user_has_approved
+                : null,
+            user_can_approve: typeof approvalState.user_can_approve === "boolean" ? approvalState.user_can_approve : null,
+            approved_by: approvedBy,
+            approved_by_usernames: approvedByUsernames,
+            rules_count: Array.isArray(approvalState.rules) ? approvalState.rules.length : null,
+            source_endpoint: approvalState.source_endpoint === "approval_state" ||
+                approvalState.source_endpoint === "approvals"
+                ? approvalState.source_endpoint
+                : null
+        };
+    }
+    catch (error) {
+        return {
+            approved: null,
+            user_has_approved: null,
+            user_can_approve: null,
+            approved_by: [],
+            approved_by_usernames: [],
+            rules_count: null,
+            source_endpoint: null,
+            unavailable_reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function getApprovalUsernames(approvalState, approvedBy) {
+    const explicit = approvalState.approved_by_usernames;
+    if (Array.isArray(explicit) && explicit.every((item) => typeof item === "string")) {
+        return explicit;
+    }
+    return approvedBy
+        .map((user) => user.username)
+        .filter((username) => typeof username === "string");
+}
+function inferMergeRequestApproved(rules) {
+    if (rules.length === 0) {
+        return null;
+    }
+    if (rules.some((rule) => typeof rule.approved !== "boolean")) {
+        return null;
+    }
+    return rules.every((rule) => rule.approved === true);
+}
 function getString(args, key) {
     const value = args[key];
     if (typeof value !== "string" || value.length === 0) {
@@ -2632,6 +5270,13 @@ function getString(args, key) {
     }
     return value;
 }
+function getIdString(args, key) {
+    const value = args[key];
+    if ((typeof value !== "string" && typeof value !== "number") || String(value).length === 0) {
+        throw new Error(`'${key}' must be a non-empty string or number`);
+    }
+    return String(value);
+}
 function getOptionalString(args, key) {
     const value = args[key];
     if (value === undefined) {
@@ -2659,6 +5304,21 @@ function getBoolean(args, key) {
     }
     return value;
 }
+function getNumber(args, key) {
+    const value = args[key];
+    const numericValue = typeof value === "string" ? Number(value) : value;
+    if (typeof numericValue !== "number" || Number.isNaN(numericValue)) {
+        throw new Error(`'${key}' must be number`);
+    }
+    return numericValue;
+}
+function getRequiredStringArray(args, key) {
+    const value = getOptionalStringArray(args, key);
+    if (!value || value.length === 0) {
+        throw new Error(`'${key}' must be a non-empty string array`);
+    }
+    return value;
+}
 function getOptionalBoolean(args, key) {
     const value = args[key];
     if (value === undefined) {
@@ -2689,6 +5349,47 @@ function getOptionalArray(args, key) {
     }
     return value;
 }
+function getWorkItemReferences(args, key, context) {
+    const values = getOptionalArray(args, key);
+    if (!values) {
+        return undefined;
+    }
+    return values.map((value) => {
+        if (typeof value !== "object" || value === null) {
+            throw new Error(`'${key}' must contain objects`);
+        }
+        const record = value;
+        if (typeof record.project_id !== "string") {
+            throw new Error(`'${key}.project_id' must be string`);
+        }
+        const iid = typeof record.iid === "string" ? Number(record.iid) : record.iid;
+        if (typeof iid !== "number" || Number.isNaN(iid)) {
+            throw new Error(`'${key}.iid' must be number`);
+        }
+        return {
+            project_id: resolveExplicitProjectId(context, record.project_id),
+            iid
+        };
+    });
+}
+function getLinkedWorkItemReferences(args, key, context) {
+    const references = getWorkItemReferences(args, key, context);
+    const rawValues = getOptionalArray(args, key);
+    if (!references || !rawValues) {
+        return references;
+    }
+    return references.map((reference, index) => {
+        const raw = rawValues[index];
+        const linkType = raw.link_type;
+        if (linkType !== undefined && typeof linkType !== "string") {
+            throw new Error(`'${key}.link_type' must be string`);
+        }
+        return {
+            ...reference,
+            link_type: linkType
+        };
+    });
+}
 function getOptionalNumberArray(args, key) {
     const value = args[key];
     if (value === undefined) {