@iloom/cli 0.9.2 → 0.10.1

package/dist/index.js

@@ -475,6 +475,7 @@ var init_logger = __esm({
 var SettingsManager_exports = {};
 __export(SettingsManager_exports, {
   AgentSettingsSchema: () => AgentSettingsSchema,
+  BaseAgentSettingsSchema: () => BaseAgentSettingsSchema,
   CapabilitiesSettingsSchema: () => CapabilitiesSettingsSchema,
   CapabilitiesSettingsSchemaNoDefaults: () => CapabilitiesSettingsSchemaNoDefaults,
   DatabaseProvidersSettingsSchema: () => DatabaseProvidersSettingsSchema,
@@ -495,14 +496,32 @@ import path2 from "path";
 import os from "os";
 import { z } from "zod";
 import deepmerge from "deepmerge";
-var PROJECT_CAPABILITIES, AgentSettingsSchema, SpinAgentSettingsSchema, PlanCommandSettingsSchema, SummarySettingsSchema, WorkflowPermissionSchema, WorkflowPermissionSchemaNoDefaults, WorkflowsSettingsSchema, WorkflowsSettingsSchemaNoDefaults, CapabilitiesSettingsSchema, CapabilitiesSettingsSchemaNoDefaults, NeonSettingsSchema, DatabaseProvidersSettingsSchema, IloomSettingsSchema, IloomSettingsSchemaNoDefaults, SettingsManager;
+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 BaseAgentSettingsSchema, AgentSettingsSchema, SpinAgentSettingsSchema, PlanCommandSettingsSchema, SummarySettingsSchema, WorkflowPermissionSchema, WorkflowPermissionSchemaNoDefaults, WorkflowsSettingsSchema, WorkflowsSettingsSchemaNoDefaults, CapabilitiesSettingsSchema, CapabilitiesSettingsSchemaNoDefaults, NeonSettingsSchema, DatabaseProvidersSettingsSchema, IloomSettingsSchema, IloomSettingsSchemaNoDefaults, SettingsManager;
 var init_SettingsManager = __esm({
   "src/lib/SettingsManager.ts"() {
     "use strict";
     init_logger();
-    PROJECT_CAPABILITIES = ["cli", "web"];
-    AgentSettingsSchema = z.object({
+    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"]),
@@ -510,8 +529,13 @@ var init_SettingsManager = __esm({
       ).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)")
     });
+    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.")
+    });
     SpinAgentSettingsSchema = z.object({
-      model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for spin orchestrator")
+      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.")
     });
     PlanCommandSettingsSchema = z.object({
       model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for plan command"),
@@ -550,19 +574,17 @@ var init_SettingsManager = __esm({
       regular: WorkflowPermissionSchemaNoDefaults.optional()
     }).optional();
     CapabilitiesSettingsSchema = z.object({
-      capabilities: z.array(z.enum(PROJECT_CAPABILITIES)).optional().describe("Explicitly declared project capabilities (auto-detected if not specified)"),
       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(),
+      }).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();
     CapabilitiesSettingsSchemaNoDefaults = z.object({
-      capabilities: z.array(z.enum(PROJECT_CAPABILITIES)).optional().describe("Explicitly declared project capabilities (auto-detected if not specified)"),
       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(),
+      }).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()
@@ -606,7 +628,7 @@ var init_SettingsManager = __esm({
       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)"
+        "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."
@@ -621,7 +643,7 @@ var init_SettingsManager = __esm({
       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"]).optional().default("github").describe("Issue tracker provider (github, linear)"),
+        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(),
@@ -629,6 +651,17 @@ var init_SettingsManager = __esm({
           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({
@@ -637,6 +670,9 @@ var init_SettingsManager = __esm({
         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({
@@ -690,10 +726,11 @@ var init_SettingsManager = __esm({
       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)"
+        "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()
+        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(),
@@ -706,7 +743,7 @@ var init_SettingsManager = __esm({
       capabilities: CapabilitiesSettingsSchemaNoDefaults.describe("Project capability configurations"),
       databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
       issueManagement: z.object({
-        provider: z.enum(["github", "linear"]).optional().describe("Issue tracker provider (github, linear)"),
+        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(),
@@ -714,6 +751,17 @@ var init_SettingsManager = __esm({
           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({
@@ -721,6 +769,9 @@ var init_SettingsManager = __esm({
         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({
@@ -757,19 +808,19 @@ var init_SettingsManager = __esm({
         const root = this.getProjectRoot(projectRoot);
         const globalSettings = await this.loadGlobalSettingsFile();
         const globalSettingsPath = this.getGlobalSettingsPath();
-        logger.debug(`\u{1F30D} Global settings from ${globalSettingsPath}:`, JSON.stringify(globalSettings, null, 2));
+        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(baseSettings, null, 2));
+        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(localSettings, null, 2));
+        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(merged, null, 2));
+        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(cliOverrides, null, 2));
+          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(merged, null, 2));
+          logger.debug("\u{1F504} After applying CLI overrides:", JSON.stringify(redactSensitiveFields(merged), null, 2));
         }
         try {
           const finalSettings = IloomSettingsSchema.parse(merged);
@@ -792,7 +843,7 @@ Note: CLI overrides were applied. Check your --set arguments.`);
        * Log the final merged configuration for debugging
        */
       logFinalConfiguration(settings) {
-        logger.debug("\u{1F4CB} Final merged configuration:", JSON.stringify(settings, null, 2));
+        logger.debug("\u{1F4CB} Final merged configuration:", JSON.stringify(redactSensitiveFields(settings), null, 2));
       }
       /**
        * Load and parse a single settings file
@@ -951,9 +1002,15 @@ ${errorMessages.join("\n")}`
        * @param settings - Pre-loaded settings object
        * @returns Model shorthand ('opus', 'sonnet', or 'haiku')
        */
-      getSpinModel(settings) {
-        var _a;
-        return ((_a = settings == null ? void 0 : settings.spin) == null ? void 0 : _a.model) ?? SpinAgentSettingsSchema.parse({}).model;
+      getSpinModel(settings, mode) {
+        var _a, _b;
+        if (mode === "swarm") {
+          if ((_a = settings == null ? void 0 : settings.spin) == null ? void 0 : _a.swarmModel) {
+            return settings.spin.swarmModel;
+          }
+          return "opus";
+        }
+        return ((_b = settings == null ? void 0 : settings.spin) == null ? void 0 : _b.model) ?? SpinAgentSettingsSchema.parse({}).model;
       }
       /**
        * Get the plan command model with default applied
@@ -1253,6 +1310,7 @@ var MetadataManager = class {
       branchName: data.branchName ?? null,
       worktreePath: data.worktreePath ?? null,
       issueType: data.issueType ?? null,
+      issueKey: data.issueKey ?? null,
       issue_numbers: data.issue_numbers ?? [],
       pr_numbers: data.pr_numbers ?? [],
       issueTracker: data.issueTracker ?? null,
@@ -1264,7 +1322,12 @@ var MetadataManager = class {
       draftPrNumber: data.draftPrNumber ?? null,
       oneShot: data.oneShot ?? null,
       capabilities: data.capabilities ?? [],
-      parentLoom: data.parentLoom ?? null
+      state: data.state ?? null,
+      childIssueNumbers: data.childIssueNumbers ?? [],
+      parentLoom: data.parentLoom ?? null,
+      childIssues: data.childIssues ?? [],
+      dependencyMap: data.dependencyMap ?? {},
+      mcpConfigPath: data.mcpConfigPath ?? null
     };
   }
   /**
@@ -1317,6 +1380,7 @@ var MetadataManager = class {
         branchName: input.branchName,
         worktreePath: input.worktreePath,
         issueType: input.issueType,
+        ...input.issueKey && { issueKey: input.issueKey },
         issue_numbers: input.issue_numbers,
         pr_numbers: input.pr_numbers,
         issueTracker: input.issueTracker,
@@ -1328,7 +1392,12 @@ var MetadataManager = class {
         capabilities: input.capabilities,
         ...input.draftPrNumber && { draftPrNumber: input.draftPrNumber },
         ...input.oneShot && { oneShot: input.oneShot },
-        ...input.parentLoom && { parentLoom: input.parentLoom }
+        ...input.state && { state: input.state },
+        ...input.childIssueNumbers && input.childIssueNumbers.length > 0 && { childIssueNumbers: input.childIssueNumbers },
+        ...input.parentLoom && { parentLoom: input.parentLoom },
+        ...input.childIssues && input.childIssues.length > 0 && { childIssues: input.childIssues },
+        ...input.dependencyMap && Object.keys(input.dependencyMap).length > 0 && { dependencyMap: input.dependencyMap },
+        ...input.mcpConfigPath && { mcpConfigPath: input.mcpConfigPath }
       };
       const filePath = this.getFilePath(worktreePath);
       await fs.writeFile(filePath, JSON.stringify(content, null, 2), { mode: 420 });
@@ -1404,6 +1473,34 @@ var MetadataManager = class {
     }
     return results;
   }
+  /**
+   * Update existing metadata for a worktree by merging new fields
+   *
+   * Reads the existing metadata file, merges the provided updates,
+   * and writes back. Only provided fields are overwritten.
+   *
+   * @param worktreePath - Absolute path to the worktree
+   * @param updates - Partial metadata fields to merge
+   */
+  async updateMetadata(worktreePath, updates) {
+    try {
+      const filePath = this.getFilePath(worktreePath);
+      if (!await fs.pathExists(filePath)) {
+        getLogger().warn(`No metadata file to update for worktree: ${worktreePath}`);
+        return;
+      }
+      const content = await fs.readFile(filePath, "utf8");
+      const data = JSON.parse(content);
+      const merged = { ...data, ...updates };
+      await fs.writeFile(filePath, JSON.stringify(merged, null, 2), { mode: 420 });
+      getLogger().debug(`Metadata updated for worktree: ${worktreePath}`);
+    } catch (error) {
+      getLogger().warn(
+        `Failed to update metadata for worktree: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
   /**
    * Delete metadata for a worktree (spec section 3.3)
    *
@@ -2769,6 +2866,65 @@ async function createIssue(title, body, options) {
     url: issueUrl
   };
 }
+async function getIssueNodeId(issueNumber, repo) {
+  logger.debug("Fetching GitHub issue node ID", { issueNumber, repo });
+  const args = ["issue", "view", String(issueNumber), "--json", "id"];
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  const result = await executeGhCommand(args);
+  return result.id;
+}
+async function getSubIssues(issueNumber, repo) {
+  var _a, _b;
+  logger.debug("Fetching GitHub sub-issues", { issueNumber, repo });
+  const parentNodeId = await getIssueNodeId(issueNumber, repo);
+  const query = `
+		query getSubIssues($parentId: ID!) {
+			node(id: $parentId) {
+				... on Issue {
+					subIssues(first: 100) {
+						nodes {
+							number
+							title
+							url
+							state
+						}
+					}
+				}
+			}
+		}
+	`;
+  try {
+    const result = await executeGhCommand([
+      "api",
+      "graphql",
+      "-H",
+      "GraphQL-Features: sub_issues",
+      "-f",
+      `query=${query}`,
+      "-F",
+      `parentId=${parentNodeId}`
+    ]);
+    const subIssues = ((_b = (_a = result.data.node) == null ? void 0 : _a.subIssues) == null ? void 0 : _b.nodes) ?? [];
+    return subIssues.map((issue) => ({
+      id: String(issue.number),
+      title: issue.title,
+      url: issue.url,
+      state: issue.state.toLowerCase()
+    }));
+  } catch (error) {
+    if (error instanceof Error) {
+      const errorMessage = error.message;
+      const stderr = "stderr" in error ? error.stderr ?? "" : "";
+      const combinedError = `${errorMessage} ${stderr}`;
+      if (combinedError.includes("sub_issues") || combinedError.includes("null")) {
+        return [];
+      }
+    }
+    throw error;
+  }
+}
 
 // src/utils/prompt.ts
 init_logger();
@@ -2951,6 +3107,14 @@ var GitHubService = class {
     const issue = await fetchGhIssue(issueNumber, repo);
     return issue.url;
   }
+  async getChildIssues(parentIdentifier, repo) {
+    const issueNum = parseInt(parentIdentifier, 10);
+    if (isNaN(issueNum)) {
+      getLogger().warn(`Invalid GitHub issue number: ${parentIdentifier}`);
+      return [];
+    }
+    return getSubIssues(issueNum, repo);
+  }
   // GitHub Projects integration
   async moveIssueToInProgress(issueNumber) {
     getLogger().info("Moving issue to In Progress in GitHub Projects", {
@@ -2986,7 +3150,48 @@ var GitHubService = class {
       await this.updateIssueStatusInProject(project, issueNumber, owner);
     }
   }
-  async updateIssueStatusInProject(project, issueNumber, owner) {
+  // GitHub Projects integration - move to Ready for Review
+  async moveIssueToReadyForReview(issueNumber) {
+    getLogger().info("Moving issue to Ready for Review in GitHub Projects", {
+      issueNumber
+    });
+    if (!await hasProjectScope()) {
+      getLogger().warn("Missing project scope in GitHub CLI auth");
+      throw new GitHubError(
+        "MISSING_SCOPE" /* MISSING_SCOPE */,
+        "GitHub CLI lacks project scope. Run: gh auth refresh -s project"
+      );
+    }
+    let owner;
+    try {
+      const repoInfo = await executeGhCommand(["repo", "view", "--json", "owner,name"]);
+      owner = repoInfo.owner.login;
+    } catch (error) {
+      getLogger().warn("Could not determine repository info", { error });
+      return;
+    }
+    let projects;
+    try {
+      projects = await fetchProjectList(owner);
+    } catch (error) {
+      getLogger().warn("Could not fetch projects", { owner, error });
+      return;
+    }
+    if (!projects.length) {
+      getLogger().warn("No projects found", { owner });
+      return;
+    }
+    for (const project of projects) {
+      await this.updateIssueStatusInProject(
+        project,
+        issueNumber,
+        owner,
+        ["Ready for Review", "In Review", "Review"],
+        "Ready for Review"
+      );
+    }
+  }
+  async updateIssueStatusInProject(project, issueNumber, owner, statusNames = ["In Progress", "In progress"], logLabel = "In Progress") {
     var _a;
     let items;
     try {
@@ -3017,11 +3222,13 @@ var GitHubService = class {
       getLogger().debug("No Status field found in project", { projectNumber: project.number });
       return;
     }
-    const inProgressOption = (_a = statusField.options) == null ? void 0 : _a.find(
-      (o) => o.name === "In Progress" || o.name === "In progress"
+    const targetOption = (_a = statusField.options) == null ? void 0 : _a.find(
+      (o) => statusNames.some(
+        (name) => o.name.toLowerCase() === name.toLowerCase()
+      )
     );
-    if (!inProgressOption) {
-      getLogger().debug("No In Progress option found in Status field", { projectNumber: project.number });
+    if (!targetOption) {
+      getLogger().debug(`No ${logLabel} option found in Status field`, { projectNumber: project.number });
       return;
     }
     try {
@@ -3029,16 +3236,21 @@ var GitHubService = class {
         item.id,
         project.id,
         statusField.id,
-        inProgressOption.id
+        targetOption.id
       );
       getLogger().info("Updated issue status in project", {
         issueNumber,
-        projectNumber: project.number
+        projectNumber: project.number,
+        status: logLabel
       });
     } catch (error) {
       getLogger().debug("Could not update project item", { item: item.id, error });
     }
   }
+  // Identifier normalization - GitHub identifiers are numeric, just stringify
+  normalizeIdentifier(identifier) {
+    return String(identifier);
+  }
   // Utility methods
   extractContext(entity) {
     if ("branch" in entity) {
@@ -3247,6 +3459,35 @@ async function updateLinearIssueState(identifier, stateName) {
     handleLinearError(error, "updateLinearIssueState");
   }
 }
+async function getLinearChildIssues(identifier, options) {
+  try {
+    logger.debug(`Fetching child issues for Linear issue: ${identifier}`);
+    const client = createLinearClient(options == null ? void 0 : options.apiToken);
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const children = await issue.children({ first: 100 });
+    const results = await Promise.all(
+      children.nodes.map(async (child) => {
+        const stateObj = await child.state;
+        const state = (stateObj == null ? void 0 : stateObj.name) ?? "unknown";
+        return {
+          id: child.identifier,
+          title: child.title,
+          url: child.url,
+          state
+        };
+      })
+    );
+    return results;
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "getLinearChildIssues");
+  }
+}
 
 // src/lib/LinearService.ts
 var LinearService = class {
@@ -3360,6 +3601,15 @@ var LinearService = class {
     const issue = await this.fetchIssue(identifier);
     return issue.url;
   }
+  /**
+   * Fetch child issues of a Linear parent issue
+   * @param parentIdentifier - Linear issue identifier (e.g., "ENG-123")
+   * @param _repo - Repository (unused for Linear)
+   * @returns Array of child issues
+   */
+  async getChildIssues(parentIdentifier, _repo) {
+    return getLinearChildIssues(parentIdentifier, this.config.apiToken ? { apiToken: this.config.apiToken } : void 0);
+  }
   /**
    * Move a Linear issue to "In Progress" state
    * @param identifier - Linear issue identifier
@@ -3369,6 +3619,23 @@ var LinearService = class {
     getLogger().info(`Moving Linear issue ${identifier} to In Progress`);
     await updateLinearIssueState(String(identifier), "In Progress");
   }
+  /**
+   * Move a Linear issue to "In Review" state
+   * @param identifier - Linear issue identifier
+   * @throws LinearServiceError if state update fails
+   */
+  async moveIssueToReadyForReview(identifier) {
+    getLogger().info(`Moving Linear issue ${identifier} to In Review`);
+    await updateLinearIssueState(String(identifier), "In Review");
+  }
+  /**
+   * Normalize identifier to canonical form (uppercase for Linear keys)
+   * @param identifier - Linear issue identifier (e.g., "eng-123" or "ENG-123")
+   * @returns Uppercase identifier (e.g., "ENG-123")
+   */
+  normalizeIdentifier(identifier) {
+    return String(identifier).toUpperCase();
+  }
   /**
    * Extract issue context for AI prompts
    * @param entity - Issue (Linear doesn't have PRs)
@@ -3400,6 +3667,844 @@ ${issue.body}`;
   }
 };
 
+// src/lib/providers/jira/JiraApiClient.ts
+import https from "https";
+
+// 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 (node.content && Array.isArray(node.content)) {
+    node.content = node.content.map((child) => sanitizeCodeMarks(child));
+  }
+  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 (node.type !== "tableCell" && node.type !== "tableHeader") {
+    return node;
+  }
+  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);
+      }
+    }
+    if (inlineRun.length > 0) {
+      newContent.push({ type: "paragraph", content: inlineRun });
+    }
+    node.content = newContent;
+  }
+  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;
+      }
+    }
+    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++;
+    }
+  }
+  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/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/IssueTrackerFactory.ts
 var IssueTrackerFactory = class {
   /**
@@ -3411,7 +4516,7 @@ var IssueTrackerFactory = class {
    * @throws Error if provider type is not supported
    */
   static create(settings) {
-    var _a, _b;
+    var _a, _b, _c;
     const provider = ((_a = settings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
     getLogger().debug(`IssueTrackerFactory: Creating tracker for provider "${provider}"`);
     getLogger().debug(`IssueTrackerFactory: issueManagement settings:`, JSON.stringify(settings.issueManagement, null, 2));
@@ -3434,6 +4539,32 @@ var IssueTrackerFactory = class {
         getLogger().debug(`IssueTrackerFactory: Creating LinearService with config:`, JSON.stringify(linearConfig, null, 2));
         return new LinearService(linearConfig);
       }
+      case "jira": {
+        const jiraSettings = (_c = settings.issueManagement) == null ? void 0 : _c.jira;
+        if (!(jiraSettings == null ? void 0 : jiraSettings.host)) {
+          throw new Error("Jira host is required. Configure issueManagement.jira.host in .iloom/settings.json");
+        }
+        if (!(jiraSettings == null ? void 0 : jiraSettings.username)) {
+          throw new Error("Jira username is required. Configure issueManagement.jira.username in .iloom/settings.json");
+        }
+        if (!(jiraSettings == null ? void 0 : jiraSettings.apiToken)) {
+          throw new Error("Jira API token is required. Configure issueManagement.jira.apiToken in .iloom/settings.local.json");
+        }
+        if (!(jiraSettings == null ? void 0 : jiraSettings.projectKey)) {
+          throw new Error("Jira project key is required. Configure issueManagement.jira.projectKey in .iloom/settings.json");
+        }
+        const jiraConfig = {
+          host: jiraSettings.host,
+          username: jiraSettings.username,
+          apiToken: jiraSettings.apiToken,
+          projectKey: jiraSettings.projectKey
+        };
+        if (jiraSettings.transitionMappings) {
+          jiraConfig.transitionMappings = jiraSettings.transitionMappings;
+        }
+        getLogger().debug(`IssueTrackerFactory: Creating JiraIssueTracker for host: ${jiraSettings.host}`);
+        return new JiraIssueTracker(jiraConfig);
+      }
       default:
         throw new Error(`Unsupported issue tracker provider: ${provider}`);
     }
@@ -3945,7 +5076,7 @@ function parseJsonStreamOutput(output) {
   }
 }
 async function launchClaude(prompt, options = {}) {
-  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents, sessionId, noSessionPersistence, outputFormat, verbose, jsonMode } = options;
+  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents, sessionId, noSessionPersistence, outputFormat, verbose, jsonMode, passthroughStdout, env: extraEnv, signal } = options;
   const log = getLogger();
   const args = [];
   if (headless) {
@@ -3989,7 +5120,37 @@ async function launchClaude(prompt, options = {}) {
   if (noSessionPersistence && headless) {
     args.push("--no-session-persistence");
   }
+  const claudeEnv = { ...process.env, CLAUDECODE: "0" };
+  function attachAbortSignal(subprocess) {
+    if (!signal) return;
+    const onAbort = () => {
+      subprocess.kill("SIGTERM");
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    subprocess.on("exit", () => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  }
   try {
+    if (headless && passthroughStdout) {
+      const subprocess = execa4("claude", args, {
+        input: prompt,
+        timeout: 0,
+        ...addDir && { cwd: addDir },
+        env: { ...claudeEnv, ...extraEnv },
+        // CLAUDECODE=0 + any extra env vars
+        stdio: ["pipe", "inherit", "pipe"]
+        // stdin: pipe (for prompt), stdout: inherit (passthrough), stderr: pipe (capture errors)
+      });
+      attachAbortSignal(subprocess);
+      try {
+        await subprocess;
+      } catch (err) {
+        if (signal == null ? void 0 : signal.aborted) return;
+        throw err;
+      }
+      return;
+    }
     if (headless) {
       const isDebugMode = logger.isDebugEnabled();
       const execaOptions = {
@@ -3999,10 +5160,13 @@ async function launchClaude(prompt, options = {}) {
         ...addDir && { cwd: addDir },
         // Run Claude in the worktree directory
         verbose: isDebugMode,
+        env: { ...claudeEnv, ...extraEnv },
+        // CLAUDECODE=0 + any extra env vars
         ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
         // Enable streaming in debug mode
       };
       const subprocess = execa4("claude", args, execaOptions);
+      attachAbortSignal(subprocess);
       const isJsonStreamFormat = args.includes("--output-format") && args.includes("stream-json");
       let outputBuffer = "";
       let isStreaming = false;
@@ -4027,7 +5191,13 @@ async function launchClaude(prompt, options = {}) {
           }
         });
       }
-      const result = await subprocess;
+      let result;
+      try {
+        result = await subprocess;
+      } catch (subprocessError) {
+        if (signal == null ? void 0 : signal.aborted) return;
+        throw subprocessError;
+      }
       if (isStreaming) {
         const rawOutput = outputBuffer.trim();
         if (!isDebugMode && !jsonMode) {
@@ -4049,16 +5219,26 @@ async function launchClaude(prompt, options = {}) {
       }
     } else {
       try {
-        await execa4("claude", [...args, "--", prompt], {
+        const interactiveSubprocess = execa4("claude", [...args, "--", prompt], {
           ...addDir && { cwd: addDir },
           stdio: ["inherit", "inherit", "pipe"],
           // Capture stderr to detect session conflicts
           timeout: 0,
           // Disable timeout
-          verbose: logger.isDebugEnabled()
+          verbose: logger.isDebugEnabled(),
+          env: { ...claudeEnv, ...extraEnv }
+          // CLAUDECODE=0 + any extra env vars
         });
+        attachAbortSignal(interactiveSubprocess);
+        try {
+          await interactiveSubprocess;
+        } catch (err) {
+          if (signal == null ? void 0 : signal.aborted) return;
+          throw err;
+        }
         return;
       } catch (interactiveError) {
+        if (signal == null ? void 0 : signal.aborted) return;
         const interactiveExecaError = interactiveError;
         const interactiveErrorMessage = interactiveExecaError.stderr ?? interactiveExecaError.message ?? "";
         const sessionMatch = interactiveErrorMessage.match(/Session ID ([0-9a-f-]+) is already in use/i);
@@ -4071,18 +5251,27 @@ async function launchClaude(prompt, options = {}) {
             return true;
           });
           resumeArgs.push("--resume", conflictSessionId);
-          await execa4("claude", resumeArgs, {
+          const resumeSubprocess = execa4("claude", resumeArgs, {
             ...addDir && { cwd: addDir },
             stdio: "inherit",
             timeout: 0,
-            verbose: logger.isDebugEnabled()
+            verbose: logger.isDebugEnabled(),
+            env: claudeEnv
           });
+          attachAbortSignal(resumeSubprocess);
+          try {
+            await resumeSubprocess;
+          } catch (err) {
+            if (signal == null ? void 0 : signal.aborted) return;
+            throw err;
+          }
           return;
         }
         throw interactiveError;
       }
     }
   } catch (error) {
+    if (signal == null ? void 0 : signal.aborted) return;
     const execaError = error;
     const errorMessage = execaError.stderr ?? execaError.message ?? "Unknown Claude CLI error";
     const sessionInUseMatch = errorMessage.match(/Session ID ([0-9a-f-]+) is already in use/i);
@@ -4103,6 +5292,7 @@ async function launchClaude(prompt, options = {}) {
             timeout: 0,
             ...addDir && { cwd: addDir },
             verbose: isDebugMode,
+            env: claudeEnv,
             ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
           };
           const subprocess = execa4("claude", resumeArgs, execaOptions);
@@ -4155,7 +5345,8 @@ async function launchClaude(prompt, options = {}) {
             ...addDir && { cwd: addDir },
             stdio: "inherit",
             timeout: 0,
-            verbose: logger.isDebugEnabled()
+            verbose: logger.isDebugEnabled(),
+            env: claudeEnv
           });
           return;
         }
@@ -4330,6 +5521,8 @@ var ClaudeService = class {
       if (port !== void 0) {
         variables.PORT = port;
       }
+      const isVscodeMode = process.env.ILOOM_VSCODE === "1";
+      variables.IS_VSCODE_MODE = isVscodeMode;
       const prompt = await this.templateManager.getPrompt(type, variables);
       const permissionMode = this.getPermissionModeForWorkflow(type);
       if (permissionMode === "bypassPermissions") {
@@ -4395,11 +5588,11 @@ var ClaudeContextManager = class {
     if (!context.workspacePath) {
       throw new Error("Workspace path is required");
     }
-    if (context.type === "issue" && typeof context.identifier !== "number") {
-      throw new Error("Issue identifier must be a number");
+    if (context.type === "issue" && context.identifier === void 0) {
+      throw new Error("Issue identifier is required");
     }
-    if (context.type === "pr" && typeof context.identifier !== "number") {
-      throw new Error("PR identifier must be a number");
+    if (context.type === "pr" && context.identifier === void 0) {
+      throw new Error("PR identifier is required");
     }
     logger.debug("Context prepared", { context });
   }
@@ -4447,6 +5640,108 @@ var UserAbortedCommitError = class extends Error {
 // src/utils/index.ts
 init_logger();
 
+// 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/utils/linear-markup-converter.ts
 import { appendFileSync } from "fs";
 import { join as join2, dirname, basename, extname } from "path";
@@ -4755,6 +6050,7 @@ export {
   GitHubService,
   GitWorktreeManager,
   IssueTrackerFactory,
+  JiraWikiSanitizer,
   LinearMarkupConverter,
   PLACEHOLDER_COMMIT_PREFIX,
   TableFormatter,