@iloom/cli 0.9.2 → 0.10.1

package/dist/mcp/issue-management-server.js

@@ -3,7 +3,7 @@
 // src/mcp/issue-management-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/utils/github.ts
 import { execa as execa2 } from "execa";
@@ -377,6 +377,41 @@ async function removeIssueDependency(blockedIssueNumber, blockingIssueDatabaseId
     apiPath
   ]);
 }
+async function closeGhIssue(issueNumber, repo) {
+  logger.debug("Closing GitHub issue", { issueNumber, repo });
+  const args = ["issue", "close", String(issueNumber)];
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  await executeGhCommand(args);
+}
+async function reopenGhIssue(issueNumber, repo) {
+  logger.debug("Reopening GitHub issue", { issueNumber, repo });
+  const args = ["issue", "reopen", String(issueNumber)];
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  await executeGhCommand(args);
+}
+async function editGhIssue(issueNumber, options, repo) {
+  logger.debug("Editing GitHub issue", { issueNumber, options, repo });
+  const args = ["issue", "edit", String(issueNumber)];
+  if (options.title !== void 0) {
+    args.push("--title", options.title);
+  }
+  if (options.body !== void 0) {
+    args.push("--body", options.body);
+  }
+  if (options.labels) {
+    if (options.labels.length > 0) {
+      args.push("--add-label", options.labels.join(","));
+    }
+  }
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  await executeGhCommand(args);
+}
 
 // src/utils/image-processor.ts
 import { tmpdir } from "os";
@@ -776,6 +811,55 @@ var GitHubIssueManagementProvider = class {
     }
     return result;
   }
+  /**
+   * Fetch PR review comments (inline code comments on specific files/lines)
+   * Uses gh api with --paginate to handle PRs with many review comments
+   * Optionally filters by review ID
+   */
+  async getReviewComments(input) {
+    const { number, reviewId, repo } = input;
+    const prNumber = parseInt(number, 10);
+    if (isNaN(prNumber)) {
+      throw new Error(`Invalid GitHub PR number: ${number}. GitHub PR IDs must be numeric.`);
+    }
+    let numericReviewId;
+    if (reviewId) {
+      numericReviewId = parseInt(reviewId, 10);
+      if (isNaN(numericReviewId)) {
+        throw new Error(`Invalid review ID: ${reviewId}. Review IDs must be numeric.`);
+      }
+    }
+    const apiPath = repo ? `repos/${repo}/pulls/${prNumber}/comments` : `repos/:owner/:repo/pulls/${prNumber}/comments`;
+    const args = [
+      "api",
+      apiPath,
+      "--paginate",
+      "--jq",
+      "[.[] | {id: .id, body: .body, path: .path, line: .line, side: .side, user: .user, created_at: .created_at, updated_at: .updated_at, in_reply_to_id: .in_reply_to_id, pull_request_review_id: .pull_request_review_id}]"
+    ];
+    const raw = await executeGhCommand(args);
+    let comments = raw;
+    if (numericReviewId !== void 0) {
+      comments = comments.filter((c) => c.pull_request_review_id === numericReviewId);
+    }
+    const results = [];
+    for (const comment of comments) {
+      const processedBody = await processMarkdownImages(comment.body, "github");
+      results.push({
+        id: String(comment.id),
+        body: processedBody,
+        path: comment.path,
+        line: comment.line,
+        side: comment.side,
+        author: normalizeAuthor(comment.user),
+        createdAt: comment.created_at,
+        updatedAt: comment.updated_at ?? null,
+        inReplyToId: comment.in_reply_to_id ? String(comment.in_reply_to_id) : null,
+        pullRequestReviewId: comment.pull_request_review_id
+      });
+    }
+    return results;
+  }
   /**
    * Fetch a specific comment by ID using gh API
    * Normalizes author to FlexibleAuthor format
@@ -935,6 +1019,55 @@ var GitHubIssueManagementProvider = class {
     }
     return await getSubIssues(issueNumber, repo);
   }
+  /**
+   * Close an issue
+   */
+  async closeIssue(input) {
+    const { number, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    await closeGhIssue(issueNumber, repo);
+  }
+  /**
+   * Reopen a closed issue
+   */
+  async reopenIssue(input) {
+    const { number, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    await reopenGhIssue(issueNumber, repo);
+  }
+  /**
+   * Edit an issue's properties
+   * State changes are delegated to closeIssue/reopenIssue
+   */
+  async editIssue(input) {
+    const { number, title, body, state, labels, repo } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    if (state === "closed") {
+      await this.closeIssue({ number, repo });
+    } else if (state === "open") {
+      await this.reopenIssue({ number, repo });
+    }
+    if (title !== void 0 || body !== void 0 || labels !== void 0) {
+      await editGhIssue(
+        issueNumber,
+        {
+          ...title !== void 0 && { title },
+          ...body !== void 0 && { body },
+          ...labels !== void 0 && { labels }
+        },
+        repo
+      );
+    }
+  }
 };
 
 // src/utils/linear.ts
@@ -1141,6 +1274,61 @@ async function createLinearComment(identifier, body) {
     handleLinearError(error, "createLinearComment");
   }
 }
+async function updateLinearIssueState(identifier, stateName) {
+  try {
+    logger.debug(`Updating Linear issue ${identifier} state to: ${stateName}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const team = await issue.team;
+    if (!team) {
+      throw new LinearServiceError("CLI_ERROR", "Issue has no team");
+    }
+    const states = await team.states();
+    const state = states.nodes.find((s) => s.name === stateName);
+    if (!state) {
+      throw new LinearServiceError(
+        "NOT_FOUND",
+        `State "${stateName}" not found in team ${team.key}`
+      );
+    }
+    await client.updateIssue(issue.id, {
+      stateId: state.id
+    });
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "updateLinearIssueState");
+  }
+}
+async function editLinearIssue(identifier, updates) {
+  try {
+    logger.debug(`Editing Linear issue ${identifier}`, { updates });
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const updatePayload = {};
+    if (updates.title !== void 0) {
+      updatePayload.title = updates.title;
+    }
+    if (updates.description !== void 0) {
+      updatePayload.description = updates.description;
+    }
+    if (Object.keys(updatePayload).length > 0) {
+      await client.updateIssue(issue.id, updatePayload);
+    }
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "editLinearIssue");
+  }
+}
 async function getLinearComment(commentId) {
   try {
     logger.debug(`Fetching Linear comment: ${commentId}`);
@@ -1711,229 +1899,2210 @@ var LinearIssueManagementProvider = class {
     const { number } = input;
     return await getLinearChildIssues(number);
   }
-};
-
-// src/mcp/IssueManagementProviderFactory.ts
-var IssueManagementProviderFactory = class {
   /**
-   * Create an issue management provider based on the provider type
+   * Close an issue by transitioning to "Done" state
    */
-  static create(provider) {
-    switch (provider) {
-      case "github":
-        return new GitHubIssueManagementProvider();
-      case "linear":
-        return new LinearIssueManagementProvider();
-      default:
-        throw new Error(`Unsupported issue management provider: ${provider}`);
+  async closeIssue(input) {
+    const { number } = input;
+    await updateLinearIssueState(number, "Done");
+  }
+  /**
+   * Reopen a closed issue by transitioning to "Todo" state
+   */
+  async reopenIssue(input) {
+    const { number } = input;
+    await updateLinearIssueState(number, "Todo");
+  }
+  /**
+   * Edit an issue's properties
+   * State changes are delegated to closeIssue/reopenIssue
+   */
+  async editIssue(input) {
+    const { number, title, body, state } = input;
+    if (state === "closed") {
+      await this.closeIssue({ number });
+    } else if (state === "open") {
+      await this.reopenIssue({ number });
+    }
+    if (title !== void 0 || body !== void 0) {
+      await editLinearIssue(number, {
+        ...title !== void 0 && { title },
+        ...body !== void 0 && { description: body }
+      });
     }
   }
 };
 
-// src/mcp/issue-management-server.ts
-function validateEnvironment() {
-  const provider = process.env.ISSUE_PROVIDER;
-  if (!provider) {
-    console.error("Missing required environment variable: ISSUE_PROVIDER");
-    process.exit(1);
+// src/utils/jira.ts
+function escapeJql(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+// src/lib/providers/jira/JiraApiClient.ts
+import https from "https";
+
+// src/utils/logger-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var loggerStorage = new AsyncLocalStorage();
+function getLogger() {
+  return loggerStorage.getStore() ?? logger;
+}
+
+// src/lib/providers/jira/AdfMarkdownConverter.ts
+import { Parser } from "extended-markdown-adf-parser";
+var parser = new Parser();
+function sanitizeCodeMarks(node) {
+  var _a;
+  if ((_a = node.marks) == null ? void 0 : _a.some((mark) => mark.type === "code")) {
+    node.marks = [{ type: "code" }];
   }
-  if (provider !== "github" && provider !== "linear") {
-    console.error(`Invalid ISSUE_PROVIDER: ${provider}. Must be 'github' or 'linear'`);
-    process.exit(1);
+  if (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => sanitizeCodeMarks(child));
   }
-  if (provider === "github") {
-    const required = ["REPO_OWNER", "REPO_NAME"];
-    const missing = required.filter((key) => !process.env[key]);
-    if (missing.length > 0) {
-      console.error(
-        `Missing required environment variables for GitHub provider: ${missing.join(", ")}`
-      );
-      process.exit(1);
-    }
+  return node;
+}
+var BLOCK_LEVEL_TYPES = /* @__PURE__ */ new Set([
+  "paragraph",
+  "bulletList",
+  "orderedList",
+  "codeBlock",
+  "heading",
+  "blockquote",
+  "rule",
+  "mediaGroup",
+  "nestedExpand",
+  "panel",
+  "table",
+  "taskList",
+  "decisionList",
+  "mediaSingle"
+]);
+function wrapTableCellContent(node) {
+  if (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => wrapTableCellContent(child));
   }
-  if (provider === "linear") {
-    if (!process.env.LINEAR_API_TOKEN) {
-      console.error("Missing required environment variable for Linear provider: LINEAR_API_TOKEN");
-      process.exit(1);
-    }
+  if (node.type !== "tableCell" && node.type !== "tableHeader") {
+    return node;
   }
-  return provider;
-}
-var server = new McpServer({
-  name: "issue-management-broker",
-  version: "0.1.0"
-});
-var flexibleAuthorSchema = z.object({
-  id: z.string(),
-  displayName: z.string()
-}).passthrough();
-server.registerTool(
-  "get_issue",
-  {
-    title: "Get Issue",
-    description: "Fetch issue details including body, title, comments, labels, assignees, and other metadata. Author fields vary by provider: GitHub uses { login }, Linear uses { name, displayName }, Jira uses { displayName, accountId }. All authors have normalized core fields: { id, displayName } plus provider-specific fields.",
-    inputSchema: {
-      number: z.string().describe("The issue identifier"),
-      includeComments: z.boolean().optional().describe("Whether to include comments (default: true)"),
-      repo: z.string().optional().describe(
-        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
-      )
-    },
-    outputSchema: {
-      // Core validated fields
-      id: z.string().describe("Issue identifier"),
-      title: z.string().describe("Issue title"),
-      body: z.string().describe("Issue body/description"),
-      state: z.string().describe("Issue state (open, closed, etc.)"),
-      url: z.string().describe("Issue URL"),
-      provider: z.enum(["github", "linear"]).describe("Issue management provider"),
-      // Flexible author - core fields + passthrough
-      author: flexibleAuthorSchema.nullable().describe(
-        "Issue author with normalized { id, displayName } plus provider-specific fields"
-      ),
-      // Optional flexible arrays
-      assignees: z.array(flexibleAuthorSchema).optional().describe(
-        "Issue assignees with normalized { id, displayName } plus provider-specific fields"
-      ),
-      labels: z.array(
-        z.object({ name: z.string() }).passthrough()
-      ).optional().describe("Issue labels"),
-      // Comments with flexible author
-      comments: z.array(
-        z.object({
-          id: z.string(),
-          body: z.string(),
-          author: flexibleAuthorSchema.nullable(),
-          createdAt: z.string()
-        }).passthrough()
-      ).optional().describe("Issue comments with flexible author structure")
+  if (!node.content || node.content.length === 0) {
+    return node;
+  }
+  const allInline = node.content.every((child) => !BLOCK_LEVEL_TYPES.has(child.type));
+  if (allInline) {
+    node.content = [{ type: "paragraph", content: node.content }];
+  } else {
+    const newContent = [];
+    let inlineRun = [];
+    for (const child of node.content) {
+      if (BLOCK_LEVEL_TYPES.has(child.type)) {
+        if (inlineRun.length > 0) {
+          newContent.push({ type: "paragraph", content: inlineRun });
+          inlineRun = [];
+        }
+        newContent.push(child);
+      } else {
+        inlineRun.push(child);
+      }
     }
-  },
-  async ({ number, includeComments, repo }) => {
-    console.error(`Fetching issue ${number}${repo ? ` from ${repo}` : ""}`);
-    try {
-      const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
-      );
-      const result = await provider.getIssue({ number, includeComments, repo });
-      console.error(`Issue fetched successfully: ${result.number} - ${result.title}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ],
-        structuredContent: result
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      console.error(`Failed to fetch issue: ${errorMessage}`);
-      throw new Error(`Failed to fetch issue: ${errorMessage}`);
+    if (inlineRun.length > 0) {
+      newContent.push({ type: "paragraph", content: inlineRun });
     }
+    node.content = newContent;
   }
-);
-server.registerTool(
-  "get_pr",
-  {
-    title: "Get Pull Request",
-    description: "Fetch pull request details including title, body, comments, files, commits, and branch information. PRs only exist on GitHub, so this tool always uses GitHub regardless of configured issue tracker. Author fields have normalized core fields: { id, displayName } plus provider-specific fields.",
-    inputSchema: {
-      number: z.string().describe("The PR number"),
-      includeComments: z.boolean().optional().describe("Whether to include comments (default: true)"),
-      repo: z.string().optional().describe(
-        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository.'
-      )
-    },
-    outputSchema: {
-      // Core validated fields
-      id: z.string().describe("PR identifier"),
-      number: z.number().describe("PR number"),
-      title: z.string().describe("PR title"),
-      body: z.string().describe("PR body/description"),
-      state: z.string().describe("PR state (OPEN, CLOSED, MERGED)"),
-      url: z.string().describe("PR URL"),
-      // Branch info
-      headRefName: z.string().describe("Source branch name"),
-      baseRefName: z.string().describe("Target branch name"),
-      // Flexible author - core fields + passthrough
-      author: flexibleAuthorSchema.nullable().describe(
-        "PR author with normalized { id, displayName } plus provider-specific fields"
-      ),
-      // Optional flexible arrays
-      files: z.array(
-        z.object({
-          path: z.string(),
-          additions: z.number(),
-          deletions: z.number()
-        }).passthrough()
-      ).optional().describe("Changed files in the PR"),
-      commits: z.array(
-        z.object({
-          oid: z.string(),
-          messageHeadline: z.string(),
-          author: flexibleAuthorSchema.nullable()
-        }).passthrough()
-      ).optional().describe("Commits in the PR"),
-      comments: z.array(
-        z.object({
-          id: z.string(),
-          body: z.string(),
-          author: flexibleAuthorSchema.nullable(),
-          createdAt: z.string()
-        }).passthrough()
-      ).optional().describe("PR comments")
+  return node;
+}
+var taskIdCounter = 0;
+function getCanonicalPlainText(text) {
+  const miniAdf = parser.markdownToAdf(text);
+  return getPlainText(miniAdf);
+}
+function extractCheckboxBlocks(markdown) {
+  var _a, _b;
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const bulletLines = [];
+    let blockIndent = null;
+    while (i < lines.length) {
+      const line = lines[i] ?? "";
+      const checkboxMatch = line.match(/^(\s*)[-*+] \[([ xX])\] (.*)$/);
+      if (checkboxMatch) {
+        const indent = ((_a = checkboxMatch[1]) == null ? void 0 : _a.length) ?? 0;
+        if (blockIndent === null) {
+          blockIndent = indent;
+        } else if (indent !== blockIndent) {
+          break;
+        }
+        const state = checkboxMatch[2] === " " ? "TODO" : "DONE";
+        bulletLines.push({ isCheckbox: true, state, rawText: checkboxMatch[3] ?? "" });
+        i++;
+      } else if (line.match(/^\s*[-*+] /)) {
+        const indentMatch = line.match(/^(\s*)/);
+        const indent = ((_b = indentMatch == null ? void 0 : indentMatch[1]) == null ? void 0 : _b.length) ?? 0;
+        if (blockIndent === null) {
+          blockIndent = indent;
+        } else if (indent !== blockIndent) {
+          break;
+        }
+        bulletLines.push({ isCheckbox: false, state: null, rawText: "" });
+        i++;
+      } else if (bulletLines.length > 0 && line.match(/^\s/) && line.trim() !== "") {
+        const lastItem = bulletLines[bulletLines.length - 1];
+        if (lastItem) {
+          lastItem.rawText += "\n" + line.trim();
+        }
+        i++;
+      } else {
+        break;
+      }
     }
-  },
-  async ({ number, includeComments, repo }) => {
-    console.error(`Fetching PR ${number}${repo ? ` from ${repo}` : ""}`);
-    try {
-      const provider = new GitHubIssueManagementProvider();
-      const result = await provider.getPR({ number, includeComments, repo });
-      console.error(`PR fetched successfully: #${result.number} - ${result.title}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ],
-        structuredContent: result
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      console.error(`Failed to fetch PR: ${errorMessage}`);
-      throw new Error(`Failed to fetch PR: ${errorMessage}`);
+    if (bulletLines.length > 0) {
+      const allCheckboxes = bulletLines.every((l) => l.isCheckbox);
+      if (allCheckboxes) {
+        blocks.push({
+          states: bulletLines.map((l) => l.state),
+          texts: bulletLines.map((l) => getCanonicalPlainText(l.rawText))
+        });
+      }
+    } else {
+      i++;
     }
   }
-);
-server.registerTool(
+  return blocks;
+}
+function getPlainText(node) {
+  if (node.type === "text" && node.text !== void 0) return node.text;
+  if (!node.content) return "";
+  return node.content.map(getPlainText).join("");
+}
+function convertCheckboxesToTaskList(node, blocks) {
+  const cursor = { index: 0 };
+  return convertCheckboxesRecursive(node, blocks, cursor);
+}
+function convertCheckboxesRecursive(node, blocks, cursor) {
+  var _a;
+  if (node.type === "bulletList" && node.content && node.content.length > 0 && cursor.index < blocks.length) {
+    const block = blocks[cursor.index];
+    if (!block) return node;
+    if (node.content.length === block.states.length) {
+      const plaintexts = node.content.map((listItem) => getPlainText(listItem));
+      const matches = plaintexts.every((text, i) => text === block.texts[i]);
+      if (matches) {
+        const allSimple = node.content.every((item) => {
+          var _a2, _b;
+          return ((_a2 = item.content) == null ? void 0 : _a2.length) === 1 && ((_b = item.content[0]) == null ? void 0 : _b.type) === "paragraph";
+        });
+        if (!allSimple) {
+          cursor.index++;
+          return node;
+        }
+        cursor.index++;
+        node.type = "taskList";
+        node.attrs = { localId: `tasklist-${++taskIdCounter}` };
+        for (const [i, listItem] of node.content.entries()) {
+          listItem.type = "taskItem";
+          listItem.attrs = {
+            localId: `task-${++taskIdCounter}`,
+            state: block.states[i]
+          };
+          const firstChild = (_a = listItem.content) == null ? void 0 : _a[0];
+          if ((firstChild == null ? void 0 : firstChild.type) === "paragraph" && firstChild.content) {
+            listItem.content = firstChild.content;
+          }
+        }
+        return node;
+      }
+    }
+  }
+  if (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => convertCheckboxesRecursive(child, blocks, cursor));
+  }
+  return node;
+}
+function convertDetailsToExpandSyntax(markdown) {
+  if (!markdown) return markdown;
+  let previousText = "";
+  let currentText = markdown;
+  while (previousText !== currentText) {
+    previousText = currentText;
+    currentText = currentText.replace(
+      /<details[^>]*>\s*<summary[^>]*>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi,
+      (_match, summary, content) => {
+        const cleanSummary = summary.trim().replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+        let cleanContent = content.trim();
+        cleanContent = cleanContent.replace(/\n{3,}/g, "\n\n");
+        if (cleanContent) {
+          return `~~~expand title="${cleanSummary}"
+${cleanContent}
+~~~`;
+        } else {
+          return `~~~expand title="${cleanSummary}"
+~~~`;
+        }
+      }
+    );
+  }
+  return currentText;
+}
+function adfToMarkdown(adf) {
+  if (!adf) return "";
+  if (typeof adf === "string") return adf;
+  return parser.adfToMarkdown(adf);
+}
+function markdownToAdf(markdown) {
+  if (!markdown) {
+    return { type: "doc", version: 1, content: [] };
+  }
+  taskIdCounter = 0;
+  const checkboxBlocks = extractCheckboxBlocks(markdown);
+  const preprocessed = convertDetailsToExpandSyntax(markdown);
+  const adf = parser.markdownToAdf(preprocessed);
+  let result = sanitizeCodeMarks(adf);
+  result = wrapTableCellContent(result);
+  result = convertCheckboxesToTaskList(result, checkboxBlocks);
+  return result;
+}
+
+// src/lib/providers/jira/JiraApiClient.ts
+var JiraApiClient = class {
+  constructor(config) {
+    this.baseUrl = `${config.host.replace(/\/$/, "")}/rest/api/3`;
+    const credentials = Buffer.from(`${config.username}:${config.apiToken}`).toString("base64");
+    this.authHeader = `Basic ${credentials}`;
+  }
+  /**
+   * Make an HTTP request to Jira API
+   */
+  async request(method, endpoint, body) {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    getLogger().debug(`Jira API ${method} request`, { url: url.toString() });
+    if (body) {
+      getLogger().debug("Jira API request body", JSON.stringify(body, null, 2));
+    }
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: url.hostname,
+        port: url.port || 443,
+        path: url.pathname + url.search,
+        method,
+        headers: {
+          "Authorization": this.authHeader,
+          "Accept": "application/json",
+          "Content-Type": "application/json"
+        }
+      };
+      const req = https.request({ ...options, timeout: 3e4 }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        res.on("end", () => {
+          var _a;
+          const data = Buffer.concat(chunks).toString("utf8");
+          if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+            let errorDetail = data;
+            try {
+              const parsed = JSON.parse(data);
+              const parts = [];
+              if ((_a = parsed.errorMessages) == null ? void 0 : _a.length) {
+                parts.push(`messages: ${parsed.errorMessages.join(", ")}`);
+              }
+              if (parsed.errors && Object.keys(parsed.errors).length) {
+                parts.push(`field errors: ${JSON.stringify(parsed.errors)}`);
+              }
+              if (parts.length) {
+                errorDetail = parts.join("; ");
+              }
+            } catch {
+            }
+            reject(new Error(`Jira API error (${res.statusCode}): ${errorDetail}`));
+            return;
+          }
+          if (res.statusCode === 204 || !data) {
+            resolve({});
+            return;
+          }
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(new Error(`Failed to parse Jira API response: ${error}`));
+          }
+        });
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Jira API request timed out after 30 seconds"));
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Jira API request failed: ${error.message}`));
+      });
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+  /**
+   * Make a GET request to Jira API
+   */
+  async get(endpoint) {
+    return this.request("GET", endpoint);
+  }
+  /**
+   * Make a POST request to Jira API
+   */
+  async post(endpoint, body) {
+    return this.request("POST", endpoint, body);
+  }
+  /**
+   * Make a PUT request to Jira API
+   */
+  async put(endpoint, body) {
+    return this.request("PUT", endpoint, body);
+  }
+  /**
+   * Make a DELETE request to Jira API
+   */
+  async delete(endpoint) {
+    await this.request("DELETE", endpoint);
+  }
+  /**
+   * Fetch an issue by key (e.g., "PROJ-123")
+   */
+  async getIssue(issueKey) {
+    return this.get(`/issue/${issueKey}`);
+  }
+  /**
+   * Add a comment to an issue
+   * Accepts Markdown content which is converted to ADF for Jira
+   */
+  async addComment(issueKey, body) {
+    const adfBody = markdownToAdf(body);
+    getLogger().debug("Adding comment to Jira issue", { issueKey, bodyLength: body.length });
+    return this.post(`/issue/${issueKey}/comment`, {
+      body: adfBody
+    });
+  }
+  /**
+   * Get all comments for an issue
+   */
+  async getComments(issueKey) {
+    const response = await this.get(`/issue/${issueKey}/comment?maxResults=5000`);
+    if (response.total > response.comments.length) {
+      getLogger().warn(`Comments truncated for issue ${issueKey}: returned ${response.comments.length} of ${response.total} total comments`);
+    }
+    return response.comments;
+  }
+  /**
+   * Update a comment on an issue
+   * Accepts Markdown content which is converted to ADF for Jira
+   */
+  async updateComment(issueKey, commentId, body) {
+    return this.put(`/issue/${issueKey}/comment/${commentId}`, {
+      body: markdownToAdf(body)
+    });
+  }
+  /**
+   * Get available transitions for an issue
+   */
+  async getTransitions(issueKey) {
+    const response = await this.get(`/issue/${issueKey}/transitions`);
+    return response.transitions;
+  }
+  /**
+   * Transition an issue to a new state
+   */
+  async transitionIssue(issueKey, transitionId) {
+    await this.post(`/issue/${issueKey}/transitions`, {
+      transition: {
+        id: transitionId
+      }
+    });
+  }
+  /**
+   * Create a new issue
+   * Accepts Markdown description which is converted to ADF for Jira
+   */
+  async createIssue(projectKey, summary, description, issueType = "Task") {
+    return this.post("/issue", {
+      fields: {
+        project: {
+          key: projectKey
+        },
+        summary,
+        description: markdownToAdf(description),
+        issuetype: {
+          name: issueType
+        }
+      }
+    });
+  }
+  /**
+   * Update an issue's fields (summary, description)
+   * @param issueKey - Jira issue key (e.g., "PROJ-123")
+   * @param fields - Fields to update
+   */
+  async updateIssue(issueKey, fields) {
+    const updateFields = {};
+    if (fields.summary !== void 0) {
+      updateFields.summary = fields.summary;
+    }
+    if (fields.description !== void 0) {
+      updateFields.description = markdownToAdf(fields.description);
+    }
+    await this.put(`/issue/${issueKey}`, { fields: updateFields });
+  }
+  /**
+   * Create an issue with a parent (subtask or child issue)
+   * Accepts Markdown description which is converted to ADF for Jira
+   */
+  async createIssueWithParent(projectKey, summary, description, parentKey, issueType = "Subtask") {
+    return this.post("/issue", {
+      fields: {
+        project: {
+          key: projectKey
+        },
+        summary,
+        description: markdownToAdf(description),
+        issuetype: {
+          name: issueType
+        },
+        parent: {
+          key: parentKey
+        }
+      }
+    });
+  }
+  /**
+   * Create an issue link (dependency/relationship between issues)
+   * @param inwardKey - The issue key for the inward side (e.g., the blocked issue)
+   * @param outwardKey - The issue key for the outward side (e.g., the blocking issue)
+   * @param linkType - The link type name (e.g., "Blocks")
+   */
+  async createIssueLink(inwardKey, outwardKey, linkType) {
+    await this.post("/issueLink", {
+      type: {
+        name: linkType
+      },
+      inwardIssue: {
+        key: inwardKey
+      },
+      outwardIssue: {
+        key: outwardKey
+      }
+    });
+  }
+  /**
+   * Delete an issue link by ID
+   */
+  async deleteIssueLink(linkId) {
+    await this.delete(`/issueLink/${linkId}`);
+  }
+  /**
+   * Search issues using JQL
+   * Automatically paginates through all results up to MAX_SEARCH_RESULTS.
+   */
+  async searchIssues(jql) {
+    const MAX_SEARCH_RESULTS = 5e3;
+    const allIssues = [];
+    let nextPageToken;
+    const maxResults = 100;
+    while (allIssues.length < MAX_SEARCH_RESULTS) {
+      const body = {
+        jql,
+        maxResults,
+        fields: [
+          "summary",
+          "description",
+          "status",
+          "issuetype",
+          "project",
+          "assignee",
+          "reporter",
+          "labels",
+          "created",
+          "updated",
+          "issuelinks",
+          "parent"
+        ]
+      };
+      if (nextPageToken) {
+        body.nextPageToken = nextPageToken;
+      }
+      const response = await this.post(
+        "/search/jql",
+        body
+      );
+      allIssues.push(...response.issues);
+      if (!response.nextPageToken || response.issues.length === 0) {
+        break;
+      }
+      nextPageToken = response.nextPageToken;
+    }
+    if (allIssues.length >= MAX_SEARCH_RESULTS) {
+      getLogger().warn(`Search results truncated at ${MAX_SEARCH_RESULTS} issues. The query matched more results than the safety cap allows.`, { jql, returnedCount: allIssues.length });
+    }
+    return allIssues;
+  }
+  /**
+   * Test connection to Jira API
+   */
+  async testConnection() {
+    try {
+      await this.get("/myself");
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Jira API error (401)") || message.includes("Jira API error (403)")) {
+        getLogger().error("Jira connection test failed: authentication error", { error });
+        return false;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/utils/prompt.ts
+import * as readline from "readline";
+
+// src/utils/notification.ts
+import net from "net";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execSync } from "child_process";
+var DEBUG = process.env.ILOOM_NOTIF_DEBUG === "1";
+
+// src/utils/prompt.ts
+async function promptConfirmation(message, defaultValue = false) {
+  const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+  const fullMessage = `${message} ${suffix}: `;
+  while (true) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(fullMessage, (ans) => {
+        rl.close();
+        resolve(ans);
+      });
+    });
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === "") {
+      return defaultValue;
+    }
+    if (normalized === "y" || normalized === "yes") {
+      return true;
+    }
+    if (normalized === "n" || normalized === "no") {
+      return false;
+    }
+    logger.warn("Invalid input. Please enter y/yes or n/no.");
+  }
+}
+
+// src/lib/providers/jira/JiraIssueTracker.ts
+var JiraIssueTracker = class {
+  constructor(config, options) {
+    this.providerName = "jira";
+    this.supportsPullRequests = false;
+    this.config = config;
+    this.client = new JiraApiClient({
+      host: config.host,
+      username: config.username,
+      apiToken: config.apiToken
+    });
+    this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
+  }
+  /**
+   * Normalize identifier to canonical uppercase form
+   * Jira issue keys are case-sensitive in the API (must be uppercase)
+   */
+  normalizeIdentifier(identifier) {
+    return String(identifier).toUpperCase();
+  }
+  /**
+   * Detect input type from user input
+   * Jira issues follow pattern: PROJECTKEY-123 (case-insensitive)
+   */
+  async detectInputType(input) {
+    const jiraPattern = /^([A-Z][A-Z0-9]+)-(\d+)$/i;
+    const match = input.match(jiraPattern);
+    if (!match) {
+      return { type: "unknown", identifier: null, rawInput: input };
+    }
+    const issueKey = this.normalizeIdentifier(input);
+    getLogger().debug("Checking if input is a Jira issue", { issueKey });
+    try {
+      await this.client.getIssue(issueKey);
+      return { type: "issue", identifier: issueKey, rawInput: input };
+    } catch (error) {
+      if (error instanceof Error && (/404/.test(error.message) || /not found/i.test(error.message))) {
+        getLogger().debug("Issue not found", { issueKey, error });
+        return { type: "unknown", identifier: null, rawInput: input };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetch issue details
+   */
+  async fetchIssue(identifier) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Fetching Jira issue", { issueKey });
+    const jiraIssue = await this.client.getIssue(issueKey);
+    return this.mapJiraIssueToIssue(jiraIssue);
+  }
+  /**
+   * Check if issue exists (silent validation)
+   */
+  async isValidIssue(identifier) {
+    try {
+      return await this.fetchIssue(identifier);
+    } catch (error) {
+      if (error instanceof Error && (/404/.test(error.message) || /not found/i.test(error.message))) {
+        getLogger().debug("Issue validation failed: not found", { identifier, error });
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate issue state
+   * Note: Jira doesn't have a simple "closed" state - depends on workflow
+   */
+  async validateIssueState(issue) {
+    getLogger().debug("Jira issue state", { issueKey: issue.number, state: issue.state });
+    if (issue.state === "closed") {
+      const shouldContinue = await this.prompter(
+        `Issue ${issue.number} is in a completed state. Continue anyway?`
+      );
+      if (!shouldContinue) {
+        throw new Error("User cancelled due to completed issue");
+      }
+    }
+  }
+  /**
+   * Create a new issue
+   */
+  async createIssue(title, body, _repository, _labels) {
+    getLogger().debug("Creating Jira issue", { title, projectKey: this.config.projectKey });
+    const jiraIssue = await this.client.createIssue(
+      this.config.projectKey,
+      title,
+      body,
+      this.config.defaultIssueType
+    );
+    return {
+      number: jiraIssue.key,
+      url: `${this.config.host}/browse/${jiraIssue.key}`
+    };
+  }
+  /**
+   * Get issue URL
+   */
+  async getIssueUrl(identifier) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    return `${this.config.host}/browse/${issueKey}`;
+  }
+  /**
+   * Move issue to "In Progress" state
+   * Uses configured transition mapping or default transition name
+   */
+  async moveIssueToInProgress(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Moving Jira issue to In Progress", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["In Progress"]) ?? this.findTransitionByName(transitions, ["In Progress", "Start Progress", "Start"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "In Progress" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue transitioned successfully", { issueKey, transition: transitionName });
+  }
+  /**
+   * Move issue to "Ready for Review" state
+   * Uses configured transition mapping or default transition name
+   */
+  async moveIssueToReadyForReview(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Moving Jira issue to Ready for Review", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["Ready for Review"]) ?? this.findTransitionByName(transitions, ["Ready for Review", "In Review", "Code Review", "Review"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "Ready for Review" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue transitioned to Ready for Review", { issueKey, transition: transitionName });
+  }
+  /**
+   * Close an issue by transitioning to "Done" state
+   * Uses configured transition mapping or default transition names
+   */
+  async closeIssue(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Closing Jira issue", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["Done"]) ?? this.findTransitionByName(transitions, ["Done", "Close", "Closed", "Resolve", "Resolved"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "Done" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue closed successfully", { issueKey, transition: transitionName });
+  }
+  /**
+   * Reopen an issue by transitioning back to an open state
+   * Uses configured transition mapping or default transition names
+   */
+  async reopenIssue(identifier) {
+    var _a;
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Reopening Jira issue", { issueKey });
+    const transitions = await this.client.getTransitions(issueKey);
+    const transitionName = ((_a = this.config.transitionMappings) == null ? void 0 : _a["Reopen"]) ?? this.findTransitionByName(transitions, ["Reopen", "To Do", "Open", "Backlog"]);
+    if (!transitionName) {
+      throw new Error(
+        `Could not find "Reopen" transition for ${issueKey}. Available transitions: ${transitions.map((t) => t.name).join(", ")}. Configure custom mapping in settings.json: issueManagement.jira.transitionMappings`
+      );
+    }
+    const transition = transitions.find((t) => t.name === transitionName);
+    if (!transition) {
+      throw new Error(`Transition "${transitionName}" not found`);
+    }
+    await this.client.transitionIssue(issueKey, transition.id);
+    getLogger().info("Issue reopened successfully", { issueKey, transition: transitionName });
+  }
+  /**
+   * Extract context from issue for AI prompts
+   */
+  extractContext(entity) {
+    return `Issue: ${entity.number}
+Title: ${entity.title}
+Status: ${entity.state}
+URL: ${entity.url}
+
+Description:
+${entity.body}
+
+${entity.labels.length > 0 ? `Labels: ${entity.labels.join(", ")}` : ""}
+${entity.assignees.length > 0 ? `Assignees: ${entity.assignees.join(", ")}` : ""}`;
+  }
+  /**
+   * Fetch child issues of a Jira parent issue using JQL
+   * @param parentIdentifier - Jira issue key (e.g., "PROJ-123")
+   * @param _repo - Repository (unused for Jira)
+   * @returns Array of child issues
+   */
+  async getChildIssues(parentIdentifier, _repo) {
+    const parentKey = this.normalizeIdentifier(parentIdentifier);
+    const jiraKeyPattern = /^[A-Z][A-Z0-9]+-\d+$/;
+    if (!jiraKeyPattern.test(parentKey)) {
+      getLogger().warn(`Invalid Jira issue key format: ${parentKey}`);
+      return [];
+    }
+    const issues = await this.client.searchIssues(`parent = ${parentKey}`);
+    return issues.map((issue) => ({
+      id: issue.key,
+      title: issue.fields.summary,
+      url: `${this.config.host}/browse/${issue.key}`,
+      state: issue.fields.status.name.toLowerCase()
+    }));
+  }
+  /**
+   * Get issue details (alias for fetchIssue for MCP compatibility)
+   */
+  async getIssue(identifier) {
+    return this.fetchIssue(identifier);
+  }
+  /**
+   * Get all comments for an issue
+   */
+  async getComments(identifier) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Fetching Jira comments", { issueKey });
+    const comments = await this.client.getComments(issueKey);
+    return comments.map((comment) => ({
+      id: comment.id,
+      body: adfToMarkdown(comment.body),
+      author: comment.author,
+      createdAt: comment.created,
+      updatedAt: comment.updated
+    }));
+  }
+  /**
+   * Add a comment to an issue
+   */
+  async addComment(identifier, body) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Adding Jira comment", { issueKey });
+    const comment = await this.client.addComment(issueKey, body);
+    return { id: comment.id };
+  }
+  /**
+   * Update an existing comment
+   */
+  async updateComment(identifier, commentId, body) {
+    const issueKey = this.normalizeIdentifier(identifier);
+    getLogger().debug("Updating Jira comment", { issueKey, commentId });
+    await this.client.updateComment(issueKey, commentId, body);
+  }
+  /**
+   * Get the underlying API client (for direct API access by MCP provider)
+   */
+  getApiClient() {
+    return this.client;
+  }
+  /**
+   * Get configuration (for MCP provider)
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Map Jira API issue to generic Issue type
+   */
+  mapJiraIssueToIssue(jiraIssue) {
+    const description = adfToMarkdown(jiraIssue.fields.description);
+    return {
+      id: jiraIssue.id,
+      key: jiraIssue.key,
+      number: jiraIssue.key,
+      title: jiraIssue.fields.summary,
+      body: description,
+      state: this.mapJiraStatusToState(jiraIssue.fields.status.name),
+      labels: jiraIssue.fields.labels,
+      assignees: jiraIssue.fields.assignee ? [jiraIssue.fields.assignee.displayName] : [],
+      assignee: jiraIssue.fields.assignee,
+      author: jiraIssue.fields.reporter,
+      url: `${this.config.host}/browse/${jiraIssue.key}`,
+      issueType: jiraIssue.fields.issuetype.name,
+      status: jiraIssue.fields.status.name
+    };
+  }
+  mapJiraStatusToState(statusName) {
+    const normalized = statusName.toLowerCase();
+    const closedStatuses = ["done", "closed", "resolved", "cancelled", "canceled"];
+    return closedStatuses.includes(normalized) ? "closed" : "open";
+  }
+  /**
+   * Find a transition by name, trying multiple possible names
+   */
+  findTransitionByName(transitions, names) {
+    for (const name of names) {
+      const transition = transitions.find(
+        (t) => t.name.toLowerCase() === name.toLowerCase()
+      );
+      if (transition) {
+        return transition.name;
+      }
+    }
+    return null;
+  }
+};
+
+// src/lib/SettingsManager.ts
+import { readFile } from "fs/promises";
+import path2 from "path";
+import os2 from "os";
+import { z } from "zod";
+import deepmerge from "deepmerge";
+var BaseAgentSettingsSchema = z.object({
+  model: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Claude model shorthand: sonnet, opus, or haiku"),
+  swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Model to use for this agent in swarm mode. Overrides the base model when running inside swarm workers."),
+  enabled: z.boolean().optional().describe("Whether this agent is enabled. Defaults to true."),
+  providers: z.record(
+    z.enum(["claude", "gemini", "codex"]),
+    z.string()
+  ).optional().describe('Map of review providers to model names. Keys: claude, gemini, codex. Values: model name strings (e.g., "sonnet", "gemini-3-pro-preview", "gpt-5.2-codex")'),
+  review: z.boolean().optional().describe("Whether artifacts from this agent should be reviewed before posting (defaults to false)")
+});
+var AgentSettingsSchema = BaseAgentSettingsSchema.extend({
+  agents: z.record(z.string(), BaseAgentSettingsSchema).optional().describe("Nested per-agent settings. Only meaningful under the iloom-swarm-worker agent entry for sub-agent timeout configuration."),
+  subAgentTimeout: z.number().min(1, "Sub-agent timeout must be at least 1 minute").max(120, "Sub-agent timeout cannot exceed 120 minutes").default(10).describe("Timeout in minutes for sub-agent claude -p invocations in swarm mode. Applies to each phase agent (evaluator, analyzer, planner, implementer) when invoked via the Bash tool. Default: 10 minutes. Only meaningful under the iloom-swarm-worker agent entry.")
+});
+var SpinAgentSettingsSchema = z.object({
+  model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for spin orchestrator"),
+  swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Model for the spin orchestrator when running in swarm mode. Overrides spin.model for swarm workflows.")
+});
+var PlanCommandSettingsSchema = z.object({
+  model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for plan command"),
+  planner: z.enum(["claude", "gemini", "codex"]).default("claude").describe("AI provider for creating the plan"),
+  reviewer: z.enum(["claude", "gemini", "codex", "none"]).default("none").describe("AI provider for reviewing the plan (none to skip review)")
+});
+var SummarySettingsSchema = z.object({
+  model: z.enum(["sonnet", "opus", "haiku"]).default("sonnet").describe("Claude model shorthand for session summary generation")
+});
+var WorkflowPermissionSchema = z.object({
+  permissionMode: z.enum(["plan", "acceptEdits", "bypassPermissions", "default"]).optional().describe("Permission mode for Claude CLI in this workflow type"),
+  noVerify: z.boolean().optional().describe("Skip pre-commit hooks (--no-verify) when committing during commit and finish workflows"),
+  startIde: z.boolean().default(true).describe("Launch IDE (code) when starting this workflow type"),
+  startDevServer: z.boolean().default(true).describe("Launch development server when starting this workflow type"),
+  startAiAgent: z.boolean().default(true).describe("Launch Claude Code agent when starting this workflow type"),
+  startTerminal: z.boolean().default(false).describe("Launch terminal window without dev server when starting this workflow type"),
+  generateSummary: z.boolean().default(true).describe("Generate and post Claude session summary when finishing this workflow type")
+});
+var WorkflowPermissionSchemaNoDefaults = z.object({
+  permissionMode: z.enum(["plan", "acceptEdits", "bypassPermissions", "default"]).optional().describe("Permission mode for Claude CLI in this workflow type"),
+  noVerify: z.boolean().optional().describe("Skip pre-commit hooks (--no-verify) when committing during commit and finish workflows"),
+  startIde: z.boolean().optional().describe("Launch IDE (code) when starting this workflow type"),
+  startDevServer: z.boolean().optional().describe("Launch development server when starting this workflow type"),
+  startAiAgent: z.boolean().optional().describe("Launch Claude Code agent when starting this workflow type"),
+  startTerminal: z.boolean().optional().describe("Launch terminal window without dev server when starting this workflow type"),
+  generateSummary: z.boolean().optional().describe("Generate and post Claude session summary when finishing this workflow type")
+});
+var WorkflowsSettingsSchema = z.object({
+  issue: WorkflowPermissionSchema.optional(),
+  pr: WorkflowPermissionSchema.optional(),
+  regular: WorkflowPermissionSchema.optional()
+}).optional();
+var WorkflowsSettingsSchemaNoDefaults = z.object({
+  issue: WorkflowPermissionSchemaNoDefaults.optional(),
+  pr: WorkflowPermissionSchemaNoDefaults.optional(),
+  regular: WorkflowPermissionSchemaNoDefaults.optional()
+}).optional();
+var CapabilitiesSettingsSchema = z.object({
+  web: z.object({
+    basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
+  }).optional().describe('Web dev server settings. To declare a project as a web project, add "web" to the capabilities array in .iloom/package.iloom.json or .iloom/package.iloom.local.json.'),
+  database: z.object({
+    databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().default("DATABASE_URL").describe("Name of environment variable for database connection URL")
+  }).optional()
+}).optional();
+var CapabilitiesSettingsSchemaNoDefaults = z.object({
+  web: z.object({
+    basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
+  }).optional().describe('Web dev server settings. To declare a project as a web project, add "web" to the capabilities array in .iloom/package.iloom.json or .iloom/package.iloom.local.json.'),
+  database: z.object({
+    databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().describe("Name of environment variable for database connection URL")
+  }).optional()
+}).optional();
+var NeonSettingsSchema = z.object({
+  projectId: z.string().min(1).regex(/^[a-zA-Z0-9-]+$/, "Neon project ID must contain only letters, numbers, and hyphens").describe('Neon project ID found in your project URL (e.g., "fantastic-fox-3566354")'),
+  parentBranch: z.string().min(1).describe("Branch from which new database branches are created")
+});
+var DatabaseProvidersSettingsSchema = z.object({
+  neon: NeonSettingsSchema.optional().describe(
+    "Neon database configuration. Requires Neon CLI installed and authenticated for database branching."
+  )
+}).optional();
+var IloomSettingsSchema = z.object({
+  mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
+  sourceEnvOnStart: z.boolean().default(false).describe(
+    "Source all dotenv-flow files (.env, .env.local, .env.development, .env.development.local) when launching terminal processes (Claude, dev server, terminal). Files are sourced in precedence order so later files override earlier ones. NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check .env file compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify ALL your .env.* files do not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
+  ),
+  worktreePrefix: z.string().optional().refine(
+    (val) => {
+      if (val === void 0) return true;
+      if (val === "") return true;
+      const allowedChars = /^[a-zA-Z0-9\-_/]+$/;
+      if (!allowedChars.test(val)) return false;
+      if (/^[-_/]+$/.test(val)) return false;
+      const segments = val.split("/");
+      for (const segment of segments) {
+        if (segment && /^[-_]+$/.test(segment)) {
+          return false;
+        }
+      }
+      return true;
+    },
+    {
+      message: "worktreePrefix contains invalid characters. Only alphanumeric characters, hyphens (-), underscores (_), and forward slashes (/) are allowed. Use forward slashes for nested directories."
+    }
+  ).describe(
+    "Prefix for worktree directories. Empty string disables prefix. Defaults to <repo-name>-looms if not set."
+  ),
+  protectedBranches: z.array(z.string().min(1, "Protected branch name cannot be empty")).optional().describe('List of branches that cannot be deleted (defaults to [mainBranch, "main", "master", "develop"])'),
+  copyGitIgnoredPatterns: z.array(z.string().min(1, "Pattern cannot be empty")).optional().describe(`Glob patterns for gitignored files to copy to looms (e.g., ["*.db", "data/*.sqlite"]). Great for local dbs and large test data files that are too big to commit to git. Note: .env (dotenv-flow) files, iloom's and claude's local settings are automatically copied and do not need to be specified here.`),
+  workflows: WorkflowsSettingsSchema.describe("Per-workflow-type permission configurations"),
+  agents: z.record(z.string(), AgentSettingsSchema).optional().nullable().describe(
+    "Per-agent configuration overrides. Available agents: iloom-issue-analyzer (analyzes issues), iloom-issue-planner (creates implementation plans), iloom-issue-analyze-and-plan (combined analysis and planning), iloom-issue-complexity-evaluator (evaluates complexity), iloom-issue-enhancer (enhances issue descriptions), iloom-issue-implementer (implements code changes), iloom-code-reviewer (reviews code changes against requirements), iloom-artifact-reviewer (reviews artifacts before posting), iloom-swarm-worker (swarm worker agent, dynamically generated). Use swarmModel on any agent to override its model in swarm mode."
+  ),
+  spin: SpinAgentSettingsSchema.optional().describe(
+    "Spin orchestrator configuration. Model defaults to opus when not configured."
+  ),
+  plan: PlanCommandSettingsSchema.optional().describe(
+    "Plan command configuration. Model defaults to opus, planner to claude, reviewer to none when not configured."
+  ),
+  summary: SummarySettingsSchema.optional().describe(
+    "Session summary generation configuration. Model defaults to sonnet when not configured."
+  ),
+  capabilities: CapabilitiesSettingsSchema.describe("Project capability configurations"),
+  databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
+  issueManagement: z.object({
+    // SYNC: If this default changes, update displayDefaultsBox() in src/utils/first-run-setup.ts
+    provider: z.enum(["github", "linear", "jira"]).optional().default("github").describe("Issue tracker provider (github, linear, jira)"),
+    github: z.object({
+      remote: z.string().min(1, "Remote name cannot be empty").describe("Git remote name to use for GitHub operations")
+    }).optional(),
+    linear: z.object({
+      teamId: z.string().min(1, "Team ID cannot be empty").describe('Linear team identifier (e.g., "ENG", "PLAT")'),
+      branchFormat: z.string().optional().describe("Branch naming template for Linear issues"),
+      apiToken: z.string().optional().describe("Linear API token (lin_api_...). SECURITY: Store in settings.local.json only, never commit to source control.")
+    }).optional(),
+    jira: z.object({
+      host: z.string().min(1, "Jira host cannot be empty").describe('Jira instance URL (e.g., "https://yourcompany.atlassian.net")'),
+      username: z.string().min(1, "Jira username/email cannot be empty").describe("Jira username or email address"),
+      apiToken: z.string().optional().describe("Jira API token. SECURITY: Store in settings.local.json only, never commit to source control. Generate at: https://id.atlassian.com/manage-profile/security/api-tokens"),
+      projectKey: z.string().min(1, "Project key cannot be empty").describe('Jira project key (e.g., "PROJ", "ENG")'),
+      boardId: z.string().optional().describe("Jira board ID for sprint/workflow operations (optional)"),
+      transitionMappings: z.record(z.string(), z.string()).optional().describe('Map iloom states to Jira transition names (e.g., {"In Review": "Start Review"})'),
+      defaultIssueType: z.string().min(1).optional().default("Task").describe('Default Jira issue type name for creating issues (e.g., "Task", "Story", "Bug")'),
+      defaultSubtaskType: z.string().min(1).optional().default("Subtask").describe('Default Jira issue type name for creating subtasks/child issues (e.g., "Subtask", "Sub-task")'),
+      doneStatuses: z.array(z.string()).optional().default(["Done"]).describe('Status names to exclude from issue lists (e.g., ["Done", "Closed", "Verify"])')
+    }).optional()
+  }).optional().describe("Issue management configuration"),
+  mergeBehavior: z.object({
+    // SYNC: If this default changes, update displayDefaultsBox() in src/utils/first-run-setup.ts
+    mode: z.enum(["local", "github-pr", "github-draft-pr"]).default("local"),
+    remote: z.string().optional(),
+    autoCommitPush: z.boolean().optional().describe(
+      "Auto-commit and push after code review in draft PR mode. Defaults to true when mode is github-draft-pr."
+    ),
+    openBrowserOnFinish: z.boolean().default(true).describe(
+      "Open the PR in the default browser after finishing in github-pr or github-draft-pr mode. Use --no-browser flag to override."
+    )
+  }).optional().describe("Merge behavior configuration: local (merge locally), github-pr (create PR), or github-draft-pr (create draft PR at start, mark ready on finish)"),
+  ide: z.object({
+    // SYNC: If this default changes, update displayDefaultsBox() in src/utils/first-run-setup.ts
+    type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf", "antigravity"]).default("vscode").describe(
+      "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor), antigravity (Antigravity IDE)."
+    )
+  }).optional().describe(
+    "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, Windsurf, and Antigravity. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf, antigravity)."
+  ),
+  colors: z.object({
+    terminal: z.boolean().default(true).describe("Apply terminal background colors based on branch name (macOS only)"),
+    vscode: z.boolean().default(false).describe(
+      "Apply VSCode/Cursor title bar colors based on branch name. Note: This modifies .vscode/settings.json which may be in source control. Default is false for safety; enable via init or explicitly if .vscode is gitignored."
+    )
+  }).optional().describe("Color synchronization settings for workspace identification"),
+  attribution: z.enum(["off", "upstreamOnly", "on"]).default("upstreamOnly").describe(
+    'Controls when iloom attribution appears in session summaries. "off" - never show attribution. "upstreamOnly" - only show for contributions to external repositories (e.g., open source). "on" - always show attribution.'
+  ),
+  git: z.object({
+    commitTimeout: z.number().min(1e3, "Commit timeout must be at least 1000ms").max(6e5, "Commit timeout cannot exceed 600000ms (10 minutes)").default(6e4).describe("Timeout in milliseconds for git commit operations. Increase for long-running pre-commit hooks.")
+  }).default({}).describe("Git operation settings")
+});
+var IloomSettingsSchemaNoDefaults = z.object({
+  mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
+  sourceEnvOnStart: z.boolean().optional().describe(
+    "Source all dotenv-flow files (.env, .env.local, .env.development, .env.development.local) when launching terminal processes (Claude, dev server, terminal). Files are sourced in precedence order so later files override earlier ones. NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check .env compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify ALL your .env.* files do not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
+  ),
+  worktreePrefix: z.string().optional().refine(
+    (val) => {
+      if (val === void 0) return true;
+      if (val === "") return true;
+      const allowedChars = /^[a-zA-Z0-9\-_/]+$/;
+      if (!allowedChars.test(val)) return false;
+      if (/^[-_/]+$/.test(val)) return false;
+      const segments = val.split("/");
+      for (const segment of segments) {
+        if (segment && /^[-_]+$/.test(segment)) {
+          return false;
+        }
+      }
+      return true;
+    },
+    {
+      message: "worktreePrefix contains invalid characters. Only alphanumeric characters, hyphens (-), underscores (_), and forward slashes (/) are allowed. Use forward slashes for nested directories."
+    }
+  ).describe(
+    "Prefix for worktree directories. Empty string disables prefix. Defaults to <repo-name>-looms if not set."
+  ),
+  protectedBranches: z.array(z.string().min(1, "Protected branch name cannot be empty")).optional().describe('List of branches that cannot be deleted (defaults to [mainBranch, "main", "master", "develop"])'),
+  copyGitIgnoredPatterns: z.array(z.string().min(1, "Pattern cannot be empty")).optional().describe(`Glob patterns for gitignored files to copy to looms (e.g., ["*.db", "data/*.sqlite"]). Great for local dbs and large test data files that are too big to commit to git. Note: .env (dotenv-flow) files, iloom's and claude's local settings are automatically copied and do not need to be specified here.`),
+  workflows: WorkflowsSettingsSchemaNoDefaults.describe("Per-workflow-type permission configurations"),
+  agents: z.record(z.string(), AgentSettingsSchema).optional().nullable().describe(
+    "Per-agent configuration overrides. Available agents: iloom-issue-analyzer (analyzes issues), iloom-issue-planner (creates implementation plans), iloom-issue-analyze-and-plan (combined analysis and planning), iloom-issue-complexity-evaluator (evaluates complexity), iloom-issue-enhancer (enhances issue descriptions), iloom-issue-implementer (implements code changes), iloom-code-reviewer (reviews code changes against requirements), iloom-artifact-reviewer (reviews artifacts before posting), iloom-swarm-worker (swarm worker agent, dynamically generated). Use swarmModel on any agent to override its model in swarm mode."
+  ),
+  spin: z.object({
+    model: z.enum(["sonnet", "opus", "haiku"]).optional(),
+    swarmModel: z.enum(["sonnet", "opus", "haiku"]).optional()
+  }).optional().describe("Spin orchestrator configuration"),
+  plan: z.object({
+    model: z.enum(["sonnet", "opus", "haiku"]).optional(),
+    planner: z.enum(["claude", "gemini", "codex"]).optional(),
+    reviewer: z.enum(["claude", "gemini", "codex", "none"]).optional()
+  }).optional().describe("Plan command configuration"),
+  summary: z.object({
+    model: z.enum(["sonnet", "opus", "haiku"]).optional()
+  }).optional().describe("Session summary generation configuration"),
+  capabilities: CapabilitiesSettingsSchemaNoDefaults.describe("Project capability configurations"),
+  databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
+  issueManagement: z.object({
+    provider: z.enum(["github", "linear", "jira"]).optional().describe("Issue tracker provider (github, linear, jira)"),
+    github: z.object({
+      remote: z.string().min(1, "Remote name cannot be empty").describe("Git remote name to use for GitHub operations")
+    }).optional(),
+    linear: z.object({
+      teamId: z.string().min(1, "Team ID cannot be empty").describe('Linear team identifier (e.g., "ENG", "PLAT")'),
+      branchFormat: z.string().optional().describe("Branch naming template for Linear issues"),
+      apiToken: z.string().optional().describe("Linear API token (lin_api_...). SECURITY: Store in settings.local.json only, never commit to source control.")
+    }).optional(),
+    jira: z.object({
+      host: z.string().min(1, "Jira host cannot be empty").describe('Jira instance URL (e.g., "https://yourcompany.atlassian.net")'),
+      username: z.string().min(1, "Jira username/email cannot be empty").describe("Jira username or email address"),
+      apiToken: z.string().optional().describe("Jira API token. SECURITY: Store in settings.local.json only, never commit to source control. Generate at: https://id.atlassian.com/manage-profile/security/api-tokens"),
+      projectKey: z.string().min(1, "Project key cannot be empty").describe('Jira project key (e.g., "PROJ", "ENG")'),
+      boardId: z.string().optional().describe("Jira board ID for sprint/workflow operations (optional)"),
+      transitionMappings: z.record(z.string(), z.string()).optional().describe('Map iloom states to Jira transition names (e.g., {"In Review": "Start Review"})'),
+      defaultIssueType: z.string().min(1).optional().describe('Default Jira issue type name for creating issues (e.g., "Task", "Story", "Bug")'),
+      defaultSubtaskType: z.string().min(1).optional().describe('Default Jira issue type name for creating subtasks/child issues (e.g., "Subtask", "Sub-task")'),
+      doneStatuses: z.array(z.string()).optional().default(["Done"]).describe('Status names to exclude from issue lists (e.g., ["Done", "Closed", "Verify"])')
+    }).optional()
+  }).optional().describe("Issue management configuration"),
+  mergeBehavior: z.object({
+    mode: z.enum(["local", "github-pr", "github-draft-pr"]).optional(),
+    remote: z.string().optional(),
+    autoCommitPush: z.boolean().optional().describe(
+      "Auto-commit and push after code review in draft PR mode. Defaults to true when mode is github-draft-pr."
+    ),
+    openBrowserOnFinish: z.boolean().optional().describe(
+      "Open the PR in the default browser after finishing in github-pr or github-draft-pr mode. Use --no-browser flag to override."
+    )
+  }).optional().describe("Merge behavior configuration: local (merge locally), github-pr (create PR), or github-draft-pr (create draft PR at start, mark ready on finish)"),
+  ide: z.object({
+    type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf", "antigravity"]).optional().describe(
+      "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor), antigravity (Antigravity IDE)."
+    )
+  }).optional().describe(
+    "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, Windsurf, and Antigravity. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf, antigravity)."
+  ),
+  colors: z.object({
+    terminal: z.boolean().optional().describe("Apply terminal background colors based on branch name (macOS only)"),
+    vscode: z.boolean().optional().describe(
+      "Apply VSCode/Cursor title bar colors based on branch name. Note: This modifies .vscode/settings.json which may be in source control."
+    )
+  }).optional().describe("Color synchronization settings for workspace identification"),
+  attribution: z.enum(["off", "upstreamOnly", "on"]).optional().describe(
+    'Controls when iloom attribution appears in session summaries. "off" - never show attribution. "upstreamOnly" - only show for contributions to external repositories (e.g., open source). "on" - always show attribution.'
+  ),
+  git: z.object({
+    commitTimeout: z.number().min(1e3, "Commit timeout must be at least 1000ms").max(6e5, "Commit timeout cannot exceed 600000ms (10 minutes)").optional().describe("Timeout in milliseconds for git commit operations. Increase for long-running pre-commit hooks.")
+  }).optional().describe("Git operation settings")
+});
+function redactSensitiveFields(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(redactSensitiveFields);
+  const sensitiveKeys = ["apitoken", "token", "secret", "password"];
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveKeys.some((s) => lowerKey.includes(s)) && typeof value === "string") {
+      result[key] = "[REDACTED]";
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = redactSensitiveFields(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var SettingsManager = class {
+  /**
+   * Load settings from global, project, and local sources with proper precedence
+   * Merge hierarchy (lowest to highest priority):
+   * 1. Global settings (~/.config/iloom-ai/settings.json)
+   * 2. Project settings (<PROJECT_ROOT>/.iloom/settings.json)
+   * 3. Local settings (<PROJECT_ROOT>/.iloom/settings.local.json)
+   * 4. CLI overrides (--set flags)
+   * Returns empty object if all files don't exist (not an error)
+   */
+  async loadSettings(projectRoot, cliOverrides) {
+    const root = this.getProjectRoot(projectRoot);
+    const globalSettings = await this.loadGlobalSettingsFile();
+    const globalSettingsPath = this.getGlobalSettingsPath();
+    logger.debug(`\u{1F30D} Global settings from ${globalSettingsPath}:`, JSON.stringify(redactSensitiveFields(globalSettings), null, 2));
+    const baseSettings = await this.loadSettingsFile(root, "settings.json");
+    const baseSettingsPath = path2.join(root, ".iloom", "settings.json");
+    logger.debug(`\u{1F4C4} Base settings from ${baseSettingsPath}:`, JSON.stringify(redactSensitiveFields(baseSettings), null, 2));
+    const localSettings = await this.loadSettingsFile(root, "settings.local.json");
+    const localSettingsPath = path2.join(root, ".iloom", "settings.local.json");
+    logger.debug(`\u{1F4C4} Local settings from ${localSettingsPath}:`, JSON.stringify(redactSensitiveFields(localSettings), null, 2));
+    let merged = this.mergeSettings(this.mergeSettings(globalSettings, baseSettings), localSettings);
+    logger.debug("\u{1F504} After merging global + base + local settings:", JSON.stringify(redactSensitiveFields(merged), null, 2));
+    if (cliOverrides && Object.keys(cliOverrides).length > 0) {
+      logger.debug("\u2699\uFE0F CLI overrides to apply:", JSON.stringify(redactSensitiveFields(cliOverrides), null, 2));
+      merged = this.mergeSettings(merged, cliOverrides);
+      logger.debug("\u{1F504} After applying CLI overrides:", JSON.stringify(redactSensitiveFields(merged), null, 2));
+    }
+    try {
+      const finalSettings = IloomSettingsSchema.parse(merged);
+      this.logFinalConfiguration(finalSettings);
+      return finalSettings;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMsg = this.formatAllZodErrors(error, "<merged settings>");
+        if (cliOverrides && Object.keys(cliOverrides).length > 0) {
+          throw new Error(`${errorMsg.message}
+
+Note: CLI overrides were applied. Check your --set arguments.`);
+        }
+        throw errorMsg;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Log the final merged configuration for debugging
+   */
+  logFinalConfiguration(settings2) {
+    logger.debug("\u{1F4CB} Final merged configuration:", JSON.stringify(redactSensitiveFields(settings2), null, 2));
+  }
+  /**
+   * Load and parse a single settings file
+   * Returns empty object if file doesn't exist (not an error)
+   * Uses non-defaulting schema to prevent polluting partial settings with defaults before merge
+   */
+  async loadSettingsFile(projectRoot, filename) {
+    const settingsPath = path2.join(projectRoot, ".iloom", filename);
+    try {
+      const content = await readFile(settingsPath, "utf-8");
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch (error) {
+        throw new Error(
+          `Failed to parse settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Invalid JSON"}`
+        );
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(
+          `Settings validation failed at ${filename}:
+  - root: Expected object, received ${typeof parsed}`
+        );
+      }
+      return parsed;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        logger.debug(`No settings file found at ${settingsPath}, using defaults`);
+        return {};
+      }
+      throw error;
+    }
+  }
+  /**
+   * Deep merge two settings objects with priority to override
+   * Uses deepmerge library with array replacement strategy
+   */
+  mergeSettings(base, override) {
+    return deepmerge(base, override, {
+      // Replace arrays instead of concatenating them
+      arrayMerge: (_destinationArray, sourceArray) => sourceArray
+    });
+  }
+  /**
+   * Format all Zod validation errors into a single error message
+   */
+  formatAllZodErrors(error, settingsPath) {
+    const errorMessages = error.issues.map((issue) => {
+      const path3 = issue.path.length > 0 ? issue.path.join(".") : "root";
+      return `  - ${path3}: ${issue.message}`;
+    });
+    return new Error(
+      `Settings validation failed at ${settingsPath}:
+${errorMessages.join("\n")}`
+    );
+  }
+  /**
+   * Validate settings structure and model names using Zod schema
+   * This method is kept for testing purposes but uses Zod internally
+   * @internal - Only used in tests via bracket notation
+   */
+  // @ts-expect-error - Used in tests via bracket notation, TypeScript can't detect this usage
+  validateSettings(settings2) {
+    try {
+      IloomSettingsSchema.parse(settings2);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw this.formatAllZodErrors(error, "<validation>");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get project root (defaults to process.cwd())
+   */
+  getProjectRoot(projectRoot) {
+    return projectRoot ?? process.cwd();
+  }
+  /**
+   * Get global config directory path (~/.config/iloom-ai)
+   */
+  getGlobalConfigDir() {
+    return path2.join(os2.homedir(), ".config", "iloom-ai");
+  }
+  /**
+   * Get global settings file path (~/.config/iloom-ai/settings.json)
+   */
+  getGlobalSettingsPath() {
+    return path2.join(this.getGlobalConfigDir(), "settings.json");
+  }
+  /**
+   * Load and parse global settings file
+   * Returns empty object if file doesn't exist (not an error)
+   * Warns but returns empty object on validation/parse errors (graceful degradation)
+   */
+  async loadGlobalSettingsFile() {
+    const settingsPath = this.getGlobalSettingsPath();
+    try {
+      const content = await readFile(settingsPath, "utf-8");
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch (error) {
+        logger.warn(
+          `Failed to parse global settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Invalid JSON"}. Ignoring global settings.`
+        );
+        return {};
+      }
+      try {
+        const validated = IloomSettingsSchemaNoDefaults.strict().parse(parsed);
+        return validated;
+      } catch (error) {
+        if (error instanceof z.ZodError) {
+          const errorMsg = this.formatAllZodErrors(error, "global settings");
+          logger.warn(`${errorMsg.message}. Ignoring global settings.`);
+        } else {
+          logger.warn(`Validation error in global settings: ${error instanceof Error ? error.message : "Unknown error"}. Ignoring global settings.`);
+        }
+        return {};
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        logger.debug(`No global settings file found at ${settingsPath}`);
+        return {};
+      }
+      logger.warn(`Error reading global settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Unknown error"}. Ignoring global settings.`);
+      return {};
+    }
+  }
+  /**
+   * Get effective protected branches list with mainBranch always included
+   *
+   * This method provides a single source of truth for protected branches logic:
+   * 1. Use configured protectedBranches if provided
+   * 2. Otherwise use defaults: [mainBranch, 'main', 'master', 'develop']
+   * 3. ALWAYS ensure mainBranch is included even if user configured custom list
+   *
+   * @param projectRoot - Optional project root directory (defaults to process.cwd())
+   * @returns Array of protected branch names with mainBranch guaranteed to be included
+   */
+  async getProtectedBranches(projectRoot) {
+    const settings2 = await this.loadSettings(projectRoot);
+    const mainBranch = settings2.mainBranch ?? "main";
+    let protectedBranches;
+    if (settings2.protectedBranches) {
+      protectedBranches = settings2.protectedBranches.includes(mainBranch) ? settings2.protectedBranches : [mainBranch, ...settings2.protectedBranches];
+    } else {
+      protectedBranches = [mainBranch, "main", "master", "develop"];
+    }
+    return protectedBranches;
+  }
+  /**
+   * Get the spin orchestrator model with default applied
+   * Default is defined in SpinAgentSettingsSchema
+   *
+   * @param settings - Pre-loaded settings object
+   * @returns Model shorthand ('opus', 'sonnet', or 'haiku')
+   */
+  getSpinModel(settings2, mode) {
+    var _a, _b;
+    if (mode === "swarm") {
+      if ((_a = settings2 == null ? void 0 : settings2.spin) == null ? void 0 : _a.swarmModel) {
+        return settings2.spin.swarmModel;
+      }
+      return "opus";
+    }
+    return ((_b = settings2 == null ? void 0 : settings2.spin) == null ? void 0 : _b.model) ?? SpinAgentSettingsSchema.parse({}).model;
+  }
+  /**
+   * Get the plan command model with default applied
+   * Default is defined in PlanCommandSettingsSchema
+   *
+   * @param settings - Pre-loaded settings object
+   * @returns Model shorthand ('opus', 'sonnet', or 'haiku')
+   */
+  getPlanModel(settings2) {
+    var _a;
+    return ((_a = settings2 == null ? void 0 : settings2.plan) == null ? void 0 : _a.model) ?? PlanCommandSettingsSchema.parse({}).model;
+  }
+  /**
+   * Get the plan command planner with default applied
+   * Default is 'claude'
+   *
+   * @param settings - Pre-loaded settings object
+   * @returns Planner provider ('claude', 'gemini', or 'codex')
+   */
+  getPlanPlanner(settings2) {
+    var _a;
+    return ((_a = settings2 == null ? void 0 : settings2.plan) == null ? void 0 : _a.planner) ?? "claude";
+  }
+  /**
+   * Get the plan command reviewer with default applied
+   * Default is 'none' (no review step)
+   *
+   * @param settings - Pre-loaded settings object
+   * @returns Reviewer provider ('claude', 'gemini', 'codex', or 'none')
+   */
+  getPlanReviewer(settings2) {
+    var _a;
+    return ((_a = settings2 == null ? void 0 : settings2.plan) == null ? void 0 : _a.reviewer) ?? "none";
+  }
+  /**
+   * Get the session summary model with default applied
+   * Default is defined in SummarySettingsSchema
+   *
+   * @param settings - Pre-loaded settings object
+   * @returns Model shorthand ('opus', 'sonnet', or 'haiku')
+   */
+  getSummaryModel(settings2) {
+    var _a;
+    return ((_a = settings2 == null ? void 0 : settings2.summary) == null ? void 0 : _a.model) ?? SummarySettingsSchema.parse({}).model;
+  }
+};
+
+// src/mcp/JiraIssueManagementProvider.ts
+function normalizeAuthor2(author) {
+  if (!author) return null;
+  return {
+    id: author.accountId ?? author.emailAddress ?? "unknown",
+    displayName: author.displayName ?? author.emailAddress ?? "Unknown",
+    ...author.emailAddress && { email: author.emailAddress },
+    ...author.accountId && { accountId: author.accountId }
+  };
+}
+var getJiraTrackerConfig = (settings2) => {
+  var _a;
+  const jiraSettings = (_a = settings2.issueManagement) == null ? void 0 : _a.jira;
+  if ((jiraSettings == null ? void 0 : jiraSettings.host) && (jiraSettings == null ? void 0 : jiraSettings.username) && (jiraSettings == null ? void 0 : jiraSettings.apiToken) && (jiraSettings == null ? void 0 : jiraSettings.projectKey)) {
+    const config = {
+      host: jiraSettings.host,
+      username: jiraSettings.username,
+      apiToken: jiraSettings.apiToken,
+      projectKey: jiraSettings.projectKey
+    };
+    if (jiraSettings.transitionMappings) {
+      config.transitionMappings = jiraSettings.transitionMappings;
+    }
+    if (jiraSettings.defaultIssueType) {
+      config.defaultIssueType = jiraSettings.defaultIssueType;
+    }
+    if (jiraSettings.defaultSubtaskType) {
+      config.defaultSubtaskType = jiraSettings.defaultSubtaskType;
+    }
+    return config;
+  }
+  if (process.env.JIRA_HOST && process.env.JIRA_USERNAME && process.env.JIRA_API_TOKEN && process.env.JIRA_PROJECT_KEY) {
+    const config = {
+      host: process.env.JIRA_HOST,
+      username: process.env.JIRA_USERNAME,
+      apiToken: process.env.JIRA_API_TOKEN,
+      projectKey: process.env.JIRA_PROJECT_KEY
+    };
+    if (process.env.JIRA_TRANSITION_MAPPINGS) {
+      try {
+        config.transitionMappings = JSON.parse(process.env.JIRA_TRANSITION_MAPPINGS);
+      } catch {
+        throw new Error("Invalid JSON in JIRA_TRANSITION_MAPPINGS environment variable");
+      }
+    }
+    if (process.env.JIRA_DEFAULT_ISSUE_TYPE) {
+      config.defaultIssueType = process.env.JIRA_DEFAULT_ISSUE_TYPE;
+    }
+    if (process.env.JIRA_DEFAULT_SUBTASK_TYPE) {
+      config.defaultSubtaskType = process.env.JIRA_DEFAULT_SUBTASK_TYPE;
+    }
+    return config;
+  }
+  throw new Error(
+    "Missing required Jira settings: issueManagement.jira.{host, username, apiToken, projectKey} or corresponding environment variables"
+  );
+};
+var JiraIssueManagementProvider = class _JiraIssueManagementProvider {
+  constructor(settings2) {
+    this.providerName = "jira";
+    this.issuePrefix = "";
+    const config = getJiraTrackerConfig(settings2);
+    this.tracker = new JiraIssueTracker(config);
+    this.projectKey = config.projectKey;
+  }
+  /**
+   * Static factory for convenience when settings aren't pre-loaded
+   */
+  static async create() {
+    const settingsManager = new SettingsManager();
+    const settings2 = await settingsManager.loadSettings();
+    return new _JiraIssueManagementProvider(settings2);
+  }
+  /**
+   * Fetch issue details using JiraIssueTracker
+   */
+  async getIssue(input) {
+    const { number, includeComments = true } = input;
+    const issue = await this.tracker.getIssue(number);
+    const issueExt = issue;
+    const result = {
+      id: issueExt.id ?? String(issue.number),
+      title: issue.title,
+      body: issue.body,
+      state: issue.state,
+      url: issue.url,
+      provider: "jira",
+      author: normalizeAuthor2(issueExt.author),
+      number: issue.number,
+      key: issueExt.key,
+      // Preserve Jira-specific fields
+      ...issueExt.issueType && { issueType: issueExt.issueType },
+      ...issueExt.priority && { priority: issueExt.priority },
+      ...issueExt.status && { status: issueExt.status }
+    };
+    if (issue.labels && issue.labels.length > 0) {
+      result.labels = issue.labels.map((label) => ({ name: label }));
+    }
+    if (issue.assignees && issue.assignees.length > 0) {
+      result.assignees = issue.assignees.map((name) => ({
+        id: name,
+        displayName: name
+      }));
+    }
+    if (includeComments) {
+      const comments = await this.tracker.getComments(number);
+      result.comments = comments.map((comment) => ({
+        id: comment.id,
+        body: comment.body,
+        author: normalizeAuthor2(comment.author),
+        createdAt: comment.createdAt,
+        updatedAt: comment.updatedAt
+      }));
+    }
+    return result;
+  }
+  /**
+   * Fetch a specific comment by ID
+   */
+  async getComment(input) {
+    const { commentId, number } = input;
+    const comments = await this.tracker.getComments(number);
+    const comment = comments.find((c) => c.id === commentId);
+    if (!comment) {
+      throw new Error(`Comment ${commentId} not found on issue ${number}`);
+    }
+    return {
+      id: comment.id,
+      body: comment.body,
+      author: normalizeAuthor2(comment.author),
+      created_at: comment.createdAt,
+      updated_at: comment.updatedAt
+    };
+  }
+  /**
+   * Create a new comment on an issue
+   */
+  async createComment(input) {
+    const { number, body } = input;
+    const normalizedKey = this.tracker.normalizeIdentifier(number);
+    const comment = await this.tracker.addComment(normalizedKey, body);
+    return {
+      id: comment.id,
+      url: `${this.tracker.getConfig().host}/browse/${normalizedKey}?focusedCommentId=${comment.id}`,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Update an existing comment
+   */
+  async updateComment(input) {
+    const { commentId, number, body } = input;
+    const normalizedKey = this.tracker.normalizeIdentifier(number);
+    await this.tracker.updateComment(normalizedKey, commentId, body);
+    return {
+      id: commentId,
+      url: `${this.tracker.getConfig().host}/browse/${normalizedKey}?focusedCommentId=${commentId}`,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Create a new issue
+   */
+  async createIssue(input) {
+    const { title, body } = input;
+    const issue = await this.tracker.createIssue(title, body);
+    const result = {
+      id: String(issue.number),
+      url: issue.url
+    };
+    if (typeof issue.number === "number") {
+      result.number = issue.number;
+    }
+    return result;
+  }
+  /**
+   * Fetch pull request details
+   * Jira does not have pull requests - throw like Linear does
+   */
+  async getPR(_input) {
+    throw new Error(
+      "Jira does not support pull requests. PRs exist only on GitHub. Use the GitHub provider for PR operations."
+    );
+  }
+  /**
+   * Create a child issue linked to a parent issue
+   * Uses Jira's parent field to create a subtask
+   */
+  async createChildIssue(input) {
+    const { parentId, title, body } = input;
+    const parentKey = this.tracker.normalizeIdentifier(parentId);
+    const jiraIssue = await this.tracker.getApiClient().createIssueWithParent(
+      this.projectKey,
+      title,
+      body,
+      parentKey,
+      this.tracker.getConfig().defaultSubtaskType
+    );
+    return {
+      id: jiraIssue.key,
+      url: `${this.tracker.getConfig().host}/browse/${jiraIssue.key}`
+    };
+  }
+  /**
+   * Create a blocking dependency between two issues
+   * Uses Jira issue links with "Blocks" link type
+   */
+  async createDependency(input) {
+    const blockingKey = this.tracker.normalizeIdentifier(input.blockingIssue);
+    const blockedKey = this.tracker.normalizeIdentifier(input.blockedIssue);
+    await this.tracker.getApiClient().createIssueLink(blockingKey, blockedKey, "Blocks");
+  }
+  /**
+   * Get dependencies for an issue
+   * Parses issue links of type "Blocks"
+   */
+  async getDependencies(input) {
+    const issueKey = this.tracker.normalizeIdentifier(input.number);
+    const host = this.tracker.getConfig().host;
+    const issue = await this.tracker.getApiClient().getIssue(issueKey);
+    const links = issue.fields.issuelinks ?? [];
+    const blocking = [];
+    const blockedBy = [];
+    for (const link of links) {
+      if (link.type.name !== "Blocks") continue;
+      if (link.inwardIssue) {
+        blockedBy.push({
+          id: link.inwardIssue.key,
+          title: link.inwardIssue.fields.summary,
+          url: `${host}/browse/${link.inwardIssue.key}`,
+          state: link.inwardIssue.fields.status.name.toLowerCase()
+        });
+      }
+      if (link.outwardIssue) {
+        blocking.push({
+          id: link.outwardIssue.key,
+          title: link.outwardIssue.fields.summary,
+          url: `${host}/browse/${link.outwardIssue.key}`,
+          state: link.outwardIssue.fields.status.name.toLowerCase()
+        });
+      }
+    }
+    if (input.direction === "blocking") {
+      return { blocking, blockedBy: [] };
+    }
+    if (input.direction === "blocked_by") {
+      return { blocking: [], blockedBy };
+    }
+    return { blocking, blockedBy };
+  }
+  /**
+   * Remove a blocking dependency between two issues
+   * Finds the matching "Blocks" link and deletes it
+   */
+  async removeDependency(input) {
+    const blockingKey = this.tracker.normalizeIdentifier(input.blockingIssue);
+    const blockedKey = this.tracker.normalizeIdentifier(input.blockedIssue);
+    const issue = await this.tracker.getApiClient().getIssue(blockedKey);
+    const links = issue.fields.issuelinks ?? [];
+    const matchingLink = links.find(
+      (link) => {
+        var _a;
+        return link.type.name === "Blocks" && ((_a = link.inwardIssue) == null ? void 0 : _a.key) === blockingKey;
+      }
+    );
+    if (!matchingLink) {
+      throw new Error(
+        `No "Blocks" dependency found from ${blockingKey} to ${blockedKey}`
+      );
+    }
+    await this.tracker.getApiClient().deleteIssueLink(matchingLink.id);
+  }
+  /**
+   * Get child issues of a parent issue
+   * Uses JQL search: parent = KEY
+   */
+  async getChildIssues(input) {
+    const parentKey = this.tracker.normalizeIdentifier(input.number);
+    const host = this.tracker.getConfig().host;
+    const issues = await this.tracker.getApiClient().searchIssues(`parent = "${escapeJql(parentKey)}"`);
+    return issues.map((issue) => ({
+      id: issue.key,
+      title: issue.fields.summary,
+      url: `${host}/browse/${issue.key}`,
+      state: issue.fields.status.name.toLowerCase()
+    }));
+  }
+  /**
+   * Close an issue by transitioning to "Done" state
+   */
+  async closeIssue(input) {
+    const issueKey = this.tracker.normalizeIdentifier(input.number);
+    await this.tracker.closeIssue(issueKey);
+  }
+  /**
+   * Reopen a closed issue
+   */
+  async reopenIssue(input) {
+    const issueKey = this.tracker.normalizeIdentifier(input.number);
+    await this.tracker.reopenIssue(issueKey);
+  }
+  /**
+   * Edit an issue's properties
+   * State changes are delegated to closeIssue/reopenIssue
+   */
+  async editIssue(input) {
+    const { number, title, body, state } = input;
+    if (state === "closed") {
+      await this.closeIssue({ number });
+    } else if (state === "open") {
+      await this.reopenIssue({ number });
+    }
+    if (title !== void 0 || body !== void 0) {
+      const issueKey = this.tracker.normalizeIdentifier(number);
+      await this.tracker.getApiClient().updateIssue(issueKey, {
+        ...title !== void 0 && { summary: title },
+        ...body !== void 0 && { description: body }
+      });
+    }
+  }
+};
+
+// src/mcp/IssueManagementProviderFactory.ts
+var IssueManagementProviderFactory = class {
+  /**
+   * Create an issue management provider based on the provider type
+   * @param provider - The provider type (github, linear, jira)
+   * @param settings - Required for Jira provider, optional for others
+   */
+  static create(provider, settings2) {
+    switch (provider) {
+      case "github":
+        return new GitHubIssueManagementProvider();
+      case "linear":
+        return new LinearIssueManagementProvider();
+      case "jira":
+        if (!settings2) {
+          throw new Error("Settings required for Jira provider");
+        }
+        return new JiraIssueManagementProvider(settings2);
+      default:
+        throw new Error(`Unsupported issue management provider: ${provider}`);
+    }
+  }
+};
+
+// src/utils/jira-wiki-sanitizer.ts
+var JiraWikiSanitizer = class {
+  /**
+   * Sanitize body text by converting unambiguous Jira Wiki patterns to Markdown.
+   * Preserves content inside backtick-fenced code blocks.
+   * Returns text unchanged if no Wiki patterns detected.
+   */
+  static sanitize(text) {
+    if (!text) {
+      return "";
+    }
+    const segments = this.splitByCodeBlocks(text);
+    const converted = segments.map((segment) => {
+      if (segment.isCode) {
+        return segment.text;
+      }
+      return this.convertSegment(segment.text);
+    });
+    return converted.join("");
+  }
+  /**
+   * Check if text contains unambiguous Jira Wiki patterns.
+   * Only checks for patterns that are safe to convert.
+   */
+  static hasJiraWikiPatterns(text) {
+    if (!text) {
+      return false;
+    }
+    if (/^h[1-6]\.\s+/m.test(text)) {
+      return true;
+    }
+    if (/\{code(?::[^}]*)?\}/i.test(text)) {
+      return true;
+    }
+    if (/\{quote\}/i.test(text)) {
+      return true;
+    }
+    if (/\[[^\]|]+\|https?:\/\/[^\]]+\]/.test(text)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Split text into segments, separating existing Markdown fenced code blocks
+   * from the rest of the content. This ensures we don't modify content inside
+   * code blocks (e.g., Jira Wiki examples shown in a Markdown code block).
+   */
+  static splitByCodeBlocks(text) {
+    const segments = [];
+    const codeBlockRegex = /^(`{3,})[^\n]*\n[\s\S]*?^\1\s*$/gm;
+    let lastIndex = 0;
+    for (const match of text.matchAll(codeBlockRegex)) {
+      const matchStart = match.index ?? 0;
+      if (matchStart > lastIndex) {
+        segments.push({ text: text.slice(lastIndex, matchStart), isCode: false });
+      }
+      segments.push({ text: match[0], isCode: true });
+      lastIndex = matchStart + match[0].length;
+    }
+    if (lastIndex < text.length) {
+      segments.push({ text: text.slice(lastIndex), isCode: false });
+    }
+    return segments;
+  }
+  /**
+   * Apply all safe Jira Wiki -> Markdown conversions to a text segment.
+   */
+  static convertSegment(text) {
+    let result = text;
+    result = result.replace(/^h([1-6])\.\s+(.*?)$/gm, (_match, level, content) => {
+      const hashes = "#".repeat(parseInt(level, 10));
+      return `${hashes} ${content}`;
+    });
+    result = result.replace(
+      /\{code:([^}]+)\}\s*\n([\s\S]*?)\n?\s*\{code\}/gi,
+      (_match, lang, content) => {
+        return "```" + lang.trim() + "\n" + content + "\n```";
+      }
+    );
+    result = result.replace(
+      /\{code\}\s*\n([\s\S]*?)\n?\s*\{code\}/gi,
+      (_match, content) => {
+        return "```\n" + content + "\n```";
+      }
+    );
+    result = result.replace(
+      /\{quote\}\s*\n([\s\S]*?)\n?\s*\{quote\}/gi,
+      (_match, content) => {
+        const lines = content.split("\n");
+        return lines.map((line) => `> ${line}`).join("\n");
+      }
+    );
+    result = result.replace(
+      /\[([^\]|]+)\|(https?:\/\/[^\]]+)\]/g,
+      (_match, linkText, url) => {
+        return `[${linkText}](${url})`;
+      }
+    );
+    return result;
+  }
+};
+
+// src/mcp/issue-management-server.ts
+var settings;
+function validateEnvironment() {
+  const provider = process.env.ISSUE_PROVIDER;
+  if (!provider) {
+    console.error("Missing required environment variable: ISSUE_PROVIDER");
+    process.exit(1);
+  }
+  if (provider !== "github" && provider !== "linear" && provider !== "jira") {
+    console.error(`Invalid ISSUE_PROVIDER: ${provider}. Must be 'github', 'linear', or 'jira'`);
+    process.exit(1);
+  }
+  if (provider === "github") {
+    const required = ["REPO_OWNER", "REPO_NAME"];
+    const missing = required.filter((key) => !process.env[key]);
+    if (missing.length > 0) {
+      console.error(
+        `Missing required environment variables for GitHub provider: ${missing.join(", ")}`
+      );
+      process.exit(1);
+    }
+  }
+  if (provider === "linear") {
+    if (!process.env.LINEAR_API_TOKEN) {
+      console.error("Missing required environment variable for Linear provider: LINEAR_API_TOKEN");
+      process.exit(1);
+    }
+  }
+  if (provider === "jira") {
+    const required = ["JIRA_HOST", "JIRA_USERNAME", "JIRA_API_TOKEN", "JIRA_PROJECT_KEY"];
+    const missing = required.filter((key) => !process.env[key]);
+    if (missing.length > 0) {
+      console.error(
+        `Missing required environment variables for Jira provider: ${missing.join(", ")}`
+      );
+      process.exit(1);
+    }
+  }
+  return provider;
+}
+var server = new McpServer({
+  name: "issue-management-broker",
+  version: "0.1.0"
+});
+var flexibleAuthorSchema = z2.object({
+  id: z2.string(),
+  displayName: z2.string()
+}).passthrough();
+server.registerTool(
+  "get_issue",
+  {
+    title: "Get Issue",
+    description: "Fetch issue details including body, title, comments, labels, assignees, and other metadata. Author fields vary by provider: GitHub uses { login }, Linear uses { name, displayName }, Jira uses { displayName, accountId }. All authors have normalized core fields: { id, displayName } plus provider-specific fields.",
+    inputSchema: {
+      number: z2.string().describe("The issue identifier"),
+      includeComments: z2.boolean().optional().describe("Whether to include comments (default: true)"),
+      repo: z2.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      // Core validated fields
+      id: z2.string().describe("Issue identifier"),
+      title: z2.string().describe("Issue title"),
+      body: z2.string().describe("Issue body/description"),
+      state: z2.string().describe("Issue state (open, closed, etc.)"),
+      url: z2.string().describe("Issue URL"),
+      provider: z2.enum(["github", "linear", "jira"]).describe("Issue management provider"),
+      // Flexible author - core fields + passthrough
+      author: flexibleAuthorSchema.nullable().describe(
+        "Issue author with normalized { id, displayName } plus provider-specific fields"
+      ),
+      // Optional flexible arrays
+      assignees: z2.array(flexibleAuthorSchema).optional().describe(
+        "Issue assignees with normalized { id, displayName } plus provider-specific fields"
+      ),
+      labels: z2.array(
+        z2.object({ name: z2.string() }).passthrough()
+      ).optional().describe("Issue labels"),
+      // Comments with flexible author
+      comments: z2.array(
+        z2.object({
+          id: z2.string(),
+          body: z2.string(),
+          author: flexibleAuthorSchema.nullable(),
+          createdAt: z2.string()
+        }).passthrough()
+      ).optional().describe("Issue comments with flexible author structure")
+    }
+  },
+  async ({ number, includeComments, repo }) => {
+    console.error(`Fetching issue ${number}${repo ? ` from ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER,
+        settings
+      );
+      const result = await provider.getIssue({ number, includeComments, repo });
+      console.error(`Issue fetched successfully: ${result.number} - ${result.title}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to fetch issue: ${errorMessage}`);
+      throw new Error(`Failed to fetch issue: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "get_pr",
+  {
+    title: "Get Pull Request",
+    description: "Fetch pull request details including title, body, comments, files, commits, and branch information. PRs only exist on GitHub, so this tool always uses GitHub regardless of configured issue tracker. Author fields have normalized core fields: { id, displayName } plus provider-specific fields.",
+    inputSchema: {
+      number: z2.string().describe("The PR number"),
+      includeComments: z2.boolean().optional().describe("Whether to include comments (default: true)"),
+      repo: z2.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository.'
+      )
+    },
+    outputSchema: {
+      // Core validated fields
+      id: z2.string().describe("PR identifier"),
+      number: z2.number().describe("PR number"),
+      title: z2.string().describe("PR title"),
+      body: z2.string().describe("PR body/description"),
+      state: z2.string().describe("PR state (OPEN, CLOSED, MERGED)"),
+      url: z2.string().describe("PR URL"),
+      // Branch info
+      headRefName: z2.string().describe("Source branch name"),
+      baseRefName: z2.string().describe("Target branch name"),
+      // Flexible author - core fields + passthrough
+      author: flexibleAuthorSchema.nullable().describe(
+        "PR author with normalized { id, displayName } plus provider-specific fields"
+      ),
+      // Optional flexible arrays
+      files: z2.array(
+        z2.object({
+          path: z2.string(),
+          additions: z2.number(),
+          deletions: z2.number()
+        }).passthrough()
+      ).optional().describe("Changed files in the PR"),
+      commits: z2.array(
+        z2.object({
+          oid: z2.string(),
+          messageHeadline: z2.string(),
+          author: flexibleAuthorSchema.nullable()
+        }).passthrough()
+      ).optional().describe("Commits in the PR"),
+      comments: z2.array(
+        z2.object({
+          id: z2.string(),
+          body: z2.string(),
+          author: flexibleAuthorSchema.nullable(),
+          createdAt: z2.string()
+        }).passthrough()
+      ).optional().describe("PR comments")
+    }
+  },
+  async ({ number, includeComments, repo }) => {
+    console.error(`Fetching PR ${number}${repo ? ` from ${repo}` : ""}`);
+    try {
+      const provider = new GitHubIssueManagementProvider();
+      const result = await provider.getPR({ number, includeComments, repo });
+      console.error(`PR fetched successfully: #${result.number} - ${result.title}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to fetch PR: ${errorMessage}`);
+      throw new Error(`Failed to fetch PR: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "get_review_comments",
+  {
+    title: "Get PR Review Comments",
+    description: "Fetch inline code review comments on a pull request (comments on specific files and lines). Returns comments with file path, line number, diff side, author, and reply threading. Optionally filter by review ID. PRs only exist on GitHub, so this tool always uses GitHub.",
+    inputSchema: {
+      number: z2.string().describe("The PR number"),
+      reviewId: z2.string().optional().describe("Optional review ID to filter comments by a specific review"),
+      repo: z2.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository.'
+      )
+    },
+    outputSchema: {
+      comments: z2.array(
+        z2.object({
+          id: z2.string().describe("Review comment ID"),
+          body: z2.string().describe("Comment body content"),
+          path: z2.string().describe("File path the comment is on"),
+          line: z2.number().nullable().describe("Line number in the diff"),
+          side: z2.string().nullable().describe("Side of the diff (LEFT or RIGHT)"),
+          author: flexibleAuthorSchema.nullable().describe("Comment author"),
+          createdAt: z2.string().describe("Comment creation timestamp"),
+          updatedAt: z2.string().nullable().describe("Comment last updated timestamp"),
+          inReplyToId: z2.string().nullable().describe("ID of the comment this replies to"),
+          pullRequestReviewId: z2.number().nullable().describe("The review this comment belongs to")
+        })
+      ).describe("Inline review comments on the PR")
+    }
+  },
+  async ({ number, reviewId, repo }) => {
+    console.error(`Fetching review comments for PR ${number}${reviewId ? ` (review ${reviewId})` : ""}${repo ? ` from ${repo}` : ""}`);
+    try {
+      const provider = new GitHubIssueManagementProvider();
+      const comments = await provider.getReviewComments({ number, reviewId, repo });
+      console.error(`Review comments fetched successfully: ${comments.length} comments`);
+      const result = { comments };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to fetch review comments: ${errorMessage}`);
+      throw new Error(`Failed to fetch review comments: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
   "get_comment",
   {
     title: "Get Comment",
     description: "Fetch a specific comment by ID. Author has normalized core fields { id, displayName } plus provider-specific fields.",
     inputSchema: {
-      commentId: z.string().describe("The comment identifier to fetch"),
-      number: z.string().describe("The issue or PR identifier (context for providers that need it)"),
-      repo: z.string().optional().describe(
+      commentId: z2.string().describe("The comment identifier to fetch"),
+      number: z2.string().describe("The issue or PR identifier (context for providers that need it)"),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
       )
     },
     outputSchema: {
-      id: z.string().describe("Comment identifier"),
-      body: z.string().describe("Comment body content"),
+      id: z2.string().describe("Comment identifier"),
+      body: z2.string().describe("Comment body content"),
       author: flexibleAuthorSchema.nullable().describe(
         "Comment author with normalized { id, displayName } plus provider-specific fields"
       ),
-      created_at: z.string().describe("Comment creation timestamp"),
-      updated_at: z.string().optional().describe("Comment last updated timestamp")
+      created_at: z2.string().describe("Comment creation timestamp"),
+      updated_at: z2.string().optional().describe("Comment last updated timestamp")
     }
   },
   async ({ commentId, number, repo }) => {
     console.error(`Fetching comment ${commentId} from issue ${number}${repo ? ` in ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
       const result = await provider.getComment({ commentId, number, repo });
       console.error(`Comment fetched successfully: ${result.id}`);
@@ -1959,22 +4128,24 @@ server.registerTool(
     title: "Create Comment",
     description: "Create a new comment on an issue or pull request. Use this to start tracking a workflow phase.",
     inputSchema: {
-      number: z.string().describe("The issue or PR identifier"),
-      body: z.string().describe("The comment body (markdown supported)"),
-      type: z.enum(["issue", "pr"]).describe("Type of entity to comment on (issue or pr)")
+      number: z2.string().describe("The issue or PR identifier"),
+      body: z2.string().describe("The comment body (markdown supported)"),
+      type: z2.enum(["issue", "pr"]).describe("Type of entity to comment on (issue or pr)"),
+      markupLanguage: z2.literal("GFM").describe("The markup language for the body content. Must be GitHub Flavored Markdown (GFM).")
     },
     outputSchema: {
-      id: z.string(),
-      url: z.string(),
-      created_at: z.string().optional()
+      id: z2.string(),
+      url: z2.string(),
+      created_at: z2.string().optional()
     }
   },
   async ({ number, body, type }) => {
     console.error(`Creating ${type} comment on ${number}`);
     try {
+      const sanitizedBody = JiraWikiSanitizer.sanitize(body);
       const providerType = type === "pr" ? "github" : process.env.ISSUE_PROVIDER;
-      const provider = IssueManagementProviderFactory.create(providerType);
-      const result = await provider.createComment({ number, body, type });
+      const provider = IssueManagementProviderFactory.create(providerType, settings);
+      const result = await provider.createComment({ number, body: sanitizedBody, type });
       console.error(
         `Comment created successfully: ${result.id} at ${result.url}`
       );
@@ -2000,23 +4171,25 @@ server.registerTool(
     title: "Update Comment",
     description: "Update an existing comment. Use this to update progress during a workflow phase.",
     inputSchema: {
-      commentId: z.string().describe("The comment identifier to update"),
-      number: z.string().describe("The issue or PR identifier (context for providers that need it)"),
-      body: z.string().describe("The updated comment body (markdown supported)"),
-      type: z.enum(["issue", "pr"]).optional().describe("Optional type to route PR comments to GitHub regardless of configured provider")
+      commentId: z2.string().describe("The comment identifier to update"),
+      number: z2.string().describe("The issue or PR identifier (context for providers that need it)"),
+      body: z2.string().describe("The updated comment body (markdown supported)"),
+      type: z2.enum(["issue", "pr"]).optional().describe("Optional type to route PR comments to GitHub regardless of configured provider"),
+      markupLanguage: z2.literal("GFM").describe("The markup language for the body content. Must be GitHub Flavored Markdown (GFM).")
     },
     outputSchema: {
-      id: z.string(),
-      url: z.string(),
-      updated_at: z.string().optional()
+      id: z2.string(),
+      url: z2.string(),
+      updated_at: z2.string().optional()
     }
   },
   async ({ commentId, number, body, type }) => {
     console.error(`Updating comment ${commentId} on ${type === "pr" ? "PR" : "issue"} ${number}`);
     try {
+      const sanitizedBody = JiraWikiSanitizer.sanitize(body);
       const providerType = type === "pr" ? "github" : process.env.ISSUE_PROVIDER;
-      const provider = IssueManagementProviderFactory.create(providerType);
-      const result = await provider.updateComment({ commentId, number, body });
+      const provider = IssueManagementProviderFactory.create(providerType, settings);
+      const result = await provider.updateComment({ commentId, number, body: sanitizedBody });
       console.error(
         `Comment updated successfully: ${result.id} at ${result.url}`
       );
@@ -2042,27 +4215,30 @@ server.registerTool(
     title: "Create Issue",
     description: 'Create a new issue in the configured issue tracker. For GitHub: creates issue in the configured repository. For Linear: requires teamKey parameter (e.g., "ENG", "PLAT"), or configure issueManagement.linear.teamId in settings, or call get_issue first to auto-detect the team.',
     inputSchema: {
-      title: z.string().describe("The issue title"),
-      body: z.string().describe("The issue body/description (markdown supported)"),
-      labels: z.array(z.string()).optional().describe("Optional labels to apply to the issue"),
-      teamKey: z.string().optional().describe('Team key for Linear (e.g., "ENG"). Falls back to settings or team extracted from previous get_issue call. Ignored for GitHub.'),
-      repo: z.string().optional().describe(
+      title: z2.string().describe("The issue title"),
+      body: z2.string().describe("The issue body/description (markdown supported)"),
+      labels: z2.array(z2.string()).optional().describe("Optional labels to apply to the issue"),
+      teamKey: z2.string().optional().describe('Team key for Linear (e.g., "ENG"). Falls back to settings or team extracted from previous get_issue call. Ignored for GitHub.'),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
-      )
+      ),
+      markupLanguage: z2.literal("GFM").describe("The markup language for the body content. Must be GitHub Flavored Markdown (GFM).")
     },
     outputSchema: {
-      id: z.string().describe("Issue identifier"),
-      url: z.string().describe("Issue URL"),
-      number: z.number().optional().describe("Issue number (GitHub only)")
+      id: z2.string().describe("Issue identifier"),
+      url: z2.string().describe("Issue URL"),
+      number: z2.number().optional().describe("Issue number (GitHub only)")
     }
   },
   async ({ title, body, labels, teamKey, repo }) => {
     console.error(`Creating issue: ${title}${repo ? ` in ${repo}` : ""}`);
     try {
+      const sanitizedBody = JiraWikiSanitizer.sanitize(body);
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
-      const result = await provider.createIssue({ title, body, labels, teamKey, repo });
+      const result = await provider.createIssue({ title, body: sanitizedBody, labels, teamKey, repo });
       console.error(`Issue created successfully: ${result.id} at ${result.url}`);
       return {
         content: [
@@ -2086,28 +4262,31 @@ server.registerTool(
     title: "Create Child Issue",
     description: 'Create a new child issue linked to a parent issue. For GitHub: creates issue and links via sub-issue API (requires two API calls). For Linear: creates issue atomically with parent relationship. The parentId should be the parent issue identifier (GitHub issue number or Linear identifier like "ENG-123").',
     inputSchema: {
-      parentId: z.string().describe('Parent issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
-      title: z.string().describe("The child issue title"),
-      body: z.string().describe("The child issue body/description (markdown supported)"),
-      labels: z.array(z.string()).optional().describe("Optional labels to apply to the child issue"),
-      teamKey: z.string().optional().describe('Team key for Linear (e.g., "ENG"). Falls back to parent team. Ignored for GitHub.'),
-      repo: z.string().optional().describe(
+      parentId: z2.string().describe('Parent issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
+      title: z2.string().describe("The child issue title"),
+      body: z2.string().describe("The child issue body/description (markdown supported)"),
+      labels: z2.array(z2.string()).optional().describe("Optional labels to apply to the child issue"),
+      teamKey: z2.string().optional().describe('Team key for Linear (e.g., "ENG"). Falls back to parent team. Ignored for GitHub.'),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
-      )
+      ),
+      markupLanguage: z2.literal("GFM").describe("The markup language for the body content. Must be GitHub Flavored Markdown (GFM).")
     },
     outputSchema: {
-      id: z.string().describe("Issue identifier"),
-      url: z.string().describe("Issue URL"),
-      number: z.number().optional().describe("Issue number (GitHub only)")
+      id: z2.string().describe("Issue identifier"),
+      url: z2.string().describe("Issue URL"),
+      number: z2.number().optional().describe("Issue number (GitHub only)")
     }
   },
   async ({ parentId, title, body, labels, teamKey, repo }) => {
     console.error(`Creating child issue for parent ${parentId}: ${title}${repo ? ` in ${repo}` : ""}`);
     try {
+      const sanitizedBody = JiraWikiSanitizer.sanitize(body);
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
-      const result = await provider.createChildIssue({ parentId, title, body, labels, teamKey, repo });
+      const result = await provider.createChildIssue({ parentId, title, body: sanitizedBody, labels, teamKey, repo });
       console.error(`Child issue created successfully: ${result.id} at ${result.url}`);
       return {
         content: [
@@ -2125,11 +4304,11 @@ server.registerTool(
     }
   }
 );
-var dependencyResultSchema = z.object({
-  id: z.string().describe("Issue identifier"),
-  title: z.string().describe("Issue title"),
-  url: z.string().describe("Issue URL"),
-  state: z.string().describe("Issue state")
+var dependencyResultSchema = z2.object({
+  id: z2.string().describe("Issue identifier"),
+  title: z2.string().describe("Issue title"),
+  url: z2.string().describe("Issue URL"),
+  state: z2.string().describe("Issue state")
 });
 server.registerTool(
   "create_dependency",
@@ -2137,21 +4316,22 @@ server.registerTool(
     title: "Create Dependency",
     description: 'Create a blocking dependency between two issues. The blockingIssue will block the blockedIssue. For GitHub: uses the sub-issue API. For Linear: creates a "blocks" relation.',
     inputSchema: {
-      blockingIssue: z.string().describe('The issue that blocks (GitHub issue number or Linear identifier like "ENG-123")'),
-      blockedIssue: z.string().describe('The issue being blocked (GitHub issue number or Linear identifier like "ENG-123")'),
-      repo: z.string().optional().describe(
+      blockingIssue: z2.string().describe('The issue that blocks (GitHub issue number or Linear identifier like "ENG-123")'),
+      blockedIssue: z2.string().describe('The issue being blocked (GitHub issue number or Linear identifier like "ENG-123")'),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
       )
     },
     outputSchema: {
-      success: z.boolean().describe("Whether the dependency was created successfully")
+      success: z2.boolean().describe("Whether the dependency was created successfully")
     }
   },
   async ({ blockingIssue, blockedIssue, repo }) => {
     console.error(`Creating dependency: ${blockingIssue} blocks ${blockedIssue}${repo ? ` in ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
       await provider.createDependency({ blockingIssue, blockedIssue, repo });
       console.error(`Dependency created successfully: ${blockingIssue} -> ${blockedIssue}`);
@@ -2177,22 +4357,23 @@ server.registerTool(
     title: "Get Dependencies",
     description: "Get blocking/blocked_by dependencies for an issue. Returns lists of issues that this issue blocks and/or is blocked by.",
     inputSchema: {
-      number: z.string().describe('Issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
-      direction: z.enum(["blocking", "blocked_by", "both"]).describe('Which dependencies to fetch: "blocking" for issues this blocks, "blocked_by" for issues blocking this, "both" for all'),
-      repo: z.string().optional().describe(
+      number: z2.string().describe('Issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
+      direction: z2.enum(["blocking", "blocked_by", "both"]).describe('Which dependencies to fetch: "blocking" for issues this blocks, "blocked_by" for issues blocking this, "both" for all'),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
       )
     },
     outputSchema: {
-      blocking: z.array(dependencyResultSchema).describe("Issues that this issue blocks"),
-      blockedBy: z.array(dependencyResultSchema).describe("Issues that block this issue")
+      blocking: z2.array(dependencyResultSchema).describe("Issues that this issue blocks"),
+      blockedBy: z2.array(dependencyResultSchema).describe("Issues that block this issue")
     }
   },
   async ({ number, direction, repo }) => {
     console.error(`Getting dependencies for ${number} (direction: ${direction})${repo ? ` in ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
       const result = await provider.getDependencies({ number, direction, repo });
       console.error(`Dependencies fetched: ${result.blocking.length} blocking, ${result.blockedBy.length} blocked_by`);
@@ -2218,21 +4399,22 @@ server.registerTool(
     title: "Remove Dependency",
     description: "Remove a blocking dependency between two issues. The blockingIssue will no longer block the blockedIssue.",
     inputSchema: {
-      blockingIssue: z.string().describe('The issue that blocks (GitHub issue number or Linear identifier like "ENG-123")'),
-      blockedIssue: z.string().describe('The issue being blocked (GitHub issue number or Linear identifier like "ENG-123")'),
-      repo: z.string().optional().describe(
+      blockingIssue: z2.string().describe('The issue that blocks (GitHub issue number or Linear identifier like "ENG-123")'),
+      blockedIssue: z2.string().describe('The issue being blocked (GitHub issue number or Linear identifier like "ENG-123")'),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
       )
     },
     outputSchema: {
-      success: z.boolean().describe("Whether the dependency was removed successfully")
+      success: z2.boolean().describe("Whether the dependency was removed successfully")
     }
   },
   async ({ blockingIssue, blockedIssue, repo }) => {
     console.error(`Removing dependency: ${blockingIssue} blocks ${blockedIssue}${repo ? ` in ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
       await provider.removeDependency({ blockingIssue, blockedIssue, repo });
       console.error(`Dependency removed successfully: ${blockingIssue} -> ${blockedIssue}`);
@@ -2252,11 +4434,11 @@ server.registerTool(
     }
   }
 );
-var childIssueResultSchema = z.object({
-  id: z.string().describe("Issue identifier"),
-  title: z.string().describe("Issue title"),
-  url: z.string().describe("Issue URL"),
-  state: z.string().describe("Issue state")
+var childIssueResultSchema = z2.object({
+  id: z2.string().describe("Issue identifier"),
+  title: z2.string().describe("Issue title"),
+  url: z2.string().describe("Issue URL"),
+  state: z2.string().describe("Issue state")
 });
 server.registerTool(
   "get_child_issues",
@@ -2264,20 +4446,21 @@ server.registerTool(
     title: "Get Child Issues",
     description: "Get child issues (sub-issues) of a parent issue. Returns a list of issues that are children of the specified parent.",
     inputSchema: {
-      number: z.string().describe('Parent issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
-      repo: z.string().optional().describe(
+      number: z2.string().describe('Parent issue identifier (GitHub issue number or Linear identifier like "ENG-123")'),
+      repo: z2.string().optional().describe(
         'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
       )
     },
     outputSchema: {
-      children: z.array(childIssueResultSchema).describe("Child issues of the parent")
+      children: z2.array(childIssueResultSchema).describe("Child issues of the parent")
     }
   },
   async ({ number, repo }) => {
     console.error(`Getting child issues for ${number}${repo ? ` in ${repo}` : ""}`);
     try {
       const provider = IssueManagementProviderFactory.create(
-        process.env.ISSUE_PROVIDER
+        process.env.ISSUE_PROVIDER,
+        settings
       );
       const result = await provider.getChildIssues({ number, repo });
       console.error(`Child issues fetched: ${result.length} children`);
@@ -2297,8 +4480,162 @@ server.registerTool(
     }
   }
 );
+server.registerTool(
+  "close_issue",
+  {
+    title: "Close Issue",
+    description: 'Close an issue in the configured issue tracker. For GitHub: uses `gh issue close`. For Linear: transitions issue to "Done" state. For Jira: transitions issue to "Done" state.',
+    inputSchema: {
+      number: z2.string().describe("The issue identifier"),
+      repo: z2.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      success: z2.boolean().describe("Whether the issue was closed successfully")
+    }
+  },
+  async ({ number, repo }) => {
+    console.error(`Closing issue ${number}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER,
+        settings
+      );
+      await provider.closeIssue({ number, repo });
+      console.error(`Issue closed successfully: ${number}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true })
+          }
+        ],
+        structuredContent: { success: true }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to close issue: ${errorMessage}`);
+      throw new Error(`Failed to close issue: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "reopen_issue",
+  {
+    title: "Reopen Issue",
+    description: 'Reopen a closed issue in the configured issue tracker. For GitHub: uses `gh issue reopen`. For Linear: transitions issue to "Todo" state. For Jira: transitions issue to "Reopen" or "To Do" state.',
+    inputSchema: {
+      number: z2.string().describe("The issue identifier"),
+      repo: z2.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      )
+    },
+    outputSchema: {
+      success: z2.boolean().describe("Whether the issue was reopened successfully")
+    }
+  },
+  async ({ number, repo }) => {
+    console.error(`Reopening issue ${number}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER,
+        settings
+      );
+      await provider.reopenIssue({ number, repo });
+      console.error(`Issue reopened successfully: ${number}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true })
+          }
+        ],
+        structuredContent: { success: true }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to reopen issue: ${errorMessage}`);
+      throw new Error(`Failed to reopen issue: ${errorMessage}`);
+    }
+  }
+);
+server.registerTool(
+  "edit_issue",
+  {
+    title: "Edit Issue",
+    description: "Edit an issue's properties (title, body, state, labels) in the configured issue tracker. State changes use close/reopen internally. For GitHub: uses `gh issue edit` for field updates and `gh issue close/reopen` for state. For Linear: uses Linear SDK to update fields and state transitions. For Jira: uses REST API to update fields and transitions for state.",
+    inputSchema: {
+      number: z2.string().describe("The issue identifier"),
+      title: z2.string().optional().describe("New issue title"),
+      body: z2.string().optional().describe("New issue body/description"),
+      state: z2.enum(["open", "closed"]).optional().describe("New issue state"),
+      labels: z2.array(z2.string()).optional().describe("Labels to add to the issue"),
+      repo: z2.string().optional().describe(
+        'Optional repository in "owner/repo" format or full GitHub URL. When not provided, uses the current repository. GitHub only.'
+      ),
+      markupLanguage: z2.literal("GFM").optional().describe("The markup language for the body content. Must be GitHub Flavored Markdown (GFM).")
+    },
+    outputSchema: {
+      success: z2.boolean().describe("Whether the issue was edited successfully")
+    }
+  },
+  async ({ number, title, body, state, labels, repo }) => {
+    console.error(`Editing issue ${number}${repo ? ` in ${repo}` : ""}`);
+    try {
+      const sanitizedBody = body ? JiraWikiSanitizer.sanitize(body) : void 0;
+      const provider = IssueManagementProviderFactory.create(
+        process.env.ISSUE_PROVIDER,
+        settings
+      );
+      await provider.editIssue({ number, title, body: sanitizedBody, state, labels, repo });
+      console.error(`Issue edited successfully: ${number}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true })
+          }
+        ],
+        structuredContent: { success: true }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to edit issue: ${errorMessage}`);
+      throw new Error(`Failed to edit issue: ${errorMessage}`);
+    }
+  }
+);
 async function main() {
-  console.error("Starting Issue Management MCP Server...");
+  console.error("=== Issue Management MCP Server Starting ===");
+  console.error(`PID: ${process.pid}`);
+  console.error(`Node version: ${process.version}`);
+  console.error(`CWD: ${process.cwd()}`);
+  console.error(`Script: ${new URL(import.meta.url).pathname}`);
+  const relevantEnvKeys = [
+    "ISSUE_PROVIDER",
+    "REPO_OWNER",
+    "REPO_NAME",
+    "GITHUB_API_URL",
+    "GITHUB_EVENT_NAME",
+    "DRAFT_PR_NUMBER",
+    "LINEAR_API_TOKEN",
+    "LINEAR_TEAM_KEY",
+    "JIRA_HOST",
+    "JIRA_USERNAME",
+    "JIRA_API_TOKEN",
+    "JIRA_PROJECT_KEY"
+  ];
+  console.error("Environment variables:");
+  for (const key of relevantEnvKeys) {
+    const val = process.env[key];
+    if (val !== void 0) {
+      console.error(`  ${key}=${val}`);
+    }
+  }
+  const settingsManager = new SettingsManager();
+  settings = await settingsManager.loadSettings();
+  console.error("Settings loaded");
   const provider = validateEnvironment();
   console.error("Environment validated");
   console.error(`Issue management provider: ${provider}`);
@@ -2308,7 +4645,7 @@ async function main() {
   }
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Issue Management MCP Server running on stdio transport");
+  console.error("=== Issue Management MCP Server READY (stdio transport) ===");
 }
 main().catch((error) => {
   console.error("Fatal error starting MCP server:", error);