@hienlh/ppm 0.10.5 → 0.11.1

package/src/services/jira-debug-session.service.ts

@@ -0,0 +1,240 @@
+import { chatService } from "./chat.service.ts";
+import { getDb } from "./db.service.ts";
+import { updateResultStatus, getResultById } from "./jira-watcher-db.service.ts";
+import { notificationService } from "./notification.service.ts";
+import { forwardEventToSession } from "../server/ws/chat.ts";
+import type { JiraWatcherRow } from "../types/jira.ts";
+import type { PermissionMode } from "../types/config.ts";
+
+const MAX_CONCURRENT = 2;
+const MAX_PER_PROJECT = 1;
+
+interface QueueItem {
+  resultId: number;
+  prompt?: string;
+  resume?: boolean; // reuse existing session instead of creating new
+}
+
+class JiraDebugSessionService {
+  private queue: QueueItem[] = [];
+  private active = new Map<number, AbortController>(); // resultId → abort
+  private activeByProject = new Map<string, number>(); // projectPath → count
+  private enqueuedIds = new Set<number>(); // guard against double-enqueue
+
+  /** Reset zombie results from previous server run (running/queued with no active process) */
+  init(): void {
+    const zombies = getDb().query(
+      `UPDATE jira_watch_results SET status = 'failed', ai_summary = 'Server restarted during debug'
+       WHERE status IN ('running', 'queued') AND deleted = 0 RETURNING id, issue_key`,
+    ).all() as { id: number; issue_key: string }[];
+    if (zombies.length > 0) {
+      console.log(`[jira-debug] Reset ${zombies.length} zombie results: ${zombies.map((z) => z.issue_key).join(", ")}`);
+    }
+  }
+
+  /** Enqueue a result for debug. Accepts "pending" or "failed" (retry). */
+  enqueue(resultId: number, promptOverride?: string): void {
+    if (this.enqueuedIds.has(resultId)) return; // prevent double-enqueue
+    const result = getResultById(resultId);
+    if (!result) throw new Error("Result not found");
+    if (result.status !== "pending" && result.status !== "failed") {
+      throw new Error(`Result status is "${result.status}", expected "pending" or "failed"`);
+    }
+
+    this.enqueuedIds.add(resultId);
+    updateResultStatus(resultId, "queued");
+    this.broadcastStatusChange(resultId, result.issueKey, "queued");
+    this.queue.push({ resultId, prompt: promptOverride });
+    this.processQueue();
+  }
+
+  /** Resume a failed session that already has a sessionId */
+  resumeDebug(resultId: number, prompt?: string): void {
+    if (this.enqueuedIds.has(resultId)) return;
+    const result = getResultById(resultId);
+    if (!result) throw new Error("Result not found");
+    if (result.status !== "failed") throw new Error("Only failed results can be resumed");
+    if (!result.sessionId) throw new Error("No session to resume — use debug instead");
+
+    this.enqueuedIds.add(resultId);
+    updateResultStatus(resultId, "queued");
+    this.broadcastStatusChange(resultId, result.issueKey, "queued");
+    this.queue.push({
+      resultId,
+      prompt: prompt ?? "Continue debugging. The previous session was interrupted before completing.",
+      resume: true,
+    });
+    this.processQueue();
+  }
+
+  /** Cancel a running or queued debug session */
+  cancelDebug(resultId: number): boolean {
+    // Remove from queue if still queued
+    const qIdx = this.queue.findIndex((q) => q.resultId === resultId);
+    if (qIdx >= 0) {
+      this.queue.splice(qIdx, 1);
+      this.enqueuedIds.delete(resultId);
+      const result = getResultById(resultId);
+      updateResultStatus(resultId, "failed", { aiSummary: "Cancelled by user" });
+      if (result) this.broadcastStatusChange(resultId, result.issueKey, "failed");
+      return true;
+    }
+    // Abort if actively running
+    const abort = this.active.get(resultId);
+    if (!abort) return false;
+    abort.abort();
+    const result = getResultById(resultId);
+    updateResultStatus(resultId, "failed", { aiSummary: "Cancelled by user" });
+    if (result) this.broadcastStatusChange(resultId, result.issueKey, "failed");
+    return true;
+  }
+
+  // [H2 fix] Iterate through queue to avoid head-of-line blocking
+  private processQueue(): void {
+    let i = 0;
+    while (i < this.queue.length && this.active.size < MAX_CONCURRENT) {
+      const item = this.queue[i]!;
+      const project = this.resolveProjectInfo(item.resultId);
+      if (!project) { this.queue.splice(i, 1); continue; }
+
+      const projectCount = this.activeByProject.get(project.path) ?? 0;
+      if (projectCount >= MAX_PER_PROJECT) { i++; continue; }
+
+      this.queue.splice(i, 1);
+      this.runDebugSession(item.resultId, item.prompt, project, item.resume).catch((e) => {
+        console.error(`[jira-debug] session error resultId=${item.resultId}:`, e.message);
+      });
+    }
+  }
+
+  // [H3 fix] Single method for project lookup — used by both processQueue and runDebugSession
+  private resolveProjectInfo(resultId: number): { path: string; name: string } | null {
+    return getDb().query(`
+      SELECT p.path, p.name FROM jira_watch_results r
+      JOIN jira_watchers w ON w.id = r.watcher_id
+      JOIN jira_config c ON c.id = w.jira_config_id
+      JOIN projects p ON p.id = c.project_id
+      WHERE r.id = ?
+    `).get(resultId) as { path: string; name: string } | null;
+  }
+
+  private resolveWatcherForResult(resultId: number): JiraWatcherRow | null {
+    return getDb().query(`
+      SELECT w.* FROM jira_watch_results r
+      JOIN jira_watchers w ON w.id = r.watcher_id
+      WHERE r.id = ?
+    `).get(resultId) as JiraWatcherRow | null;
+  }
+
+  private async runDebugSession(
+    resultId: number, promptOverride: string | undefined,
+    project: { path: string; name: string },
+    resume?: boolean,
+  ): Promise<void> {
+    const result = getResultById(resultId);
+    if (!result) return;
+
+    // Build prompt
+    let prompt: string;
+    if (promptOverride) {
+      prompt = promptOverride;
+    } else {
+      const watcher = this.resolveWatcherForResult(resultId);
+      if (watcher?.prompt_template) {
+        prompt = watcher.prompt_template
+          .replace(/\{issue_key\}/g, result.issueKey)
+          .replace(/\{summary\}/g, result.issueSummary ?? "")
+          .replace(/\{description\}/g, "(fetched from Jira)")
+          .replace(/\{status\}/g, "")
+          .replace(/\{priority\}/g, "");
+      } else {
+        prompt = `Debug Jira issue ${result.issueKey}: ${result.issueSummary ?? "No summary"}`;
+      }
+    }
+
+    // Track concurrency
+    const abort = new AbortController();
+    this.active.set(resultId, abort);
+    this.activeByProject.set(project.path, (this.activeByProject.get(project.path) ?? 0) + 1);
+
+    updateResultStatus(resultId, "running");
+    this.broadcastStatusChange(resultId, result.issueKey, "running");
+
+    try {
+      // Resume: reuse existing session (SDK can resume from disk even after restart)
+      let session: { id: string; providerId: string };
+      if (resume && result.sessionId) {
+        // SDK provider's sendMessage auto-resumes sessions from disk via resumeSession()
+        // We just need the sessionId and the correct providerId
+        const existing = chatService.getSession(result.sessionId);
+        session = existing
+          ? { id: existing.id, providerId: existing.providerId }
+          : { id: result.sessionId, providerId: "claude" }; // default provider
+      } else {
+        session = await chatService.createSession(undefined, {
+          projectPath: project.path,
+          projectName: project.name,
+          title: `[Jira Debug] ${result.issueKey}: ${(result.issueSummary ?? "").slice(0, 50)}`,
+        });
+      }
+
+      // Persist sessionId immediately so UI can show "Open" button while running
+      updateResultStatus(resultId, "running", { sessionId: session.id });
+      this.broadcastStatusChange(resultId, result.issueKey, "running", session.id);
+
+      // bypassPermissions: automated debug sessions run without user approval (same as PPMBot)
+      const opts = { permissionMode: "bypassPermissions" as PermissionMode };
+      const events = chatService.sendMessage(session.providerId, session.id, prompt, opts);
+
+      let lastAssistantText = "";
+      for await (const event of events) {
+        if (abort.signal.aborted) break;
+        if (event.type === "text") lastAssistantText = event.content;
+        // Forward events to any connected WS client viewing this session
+        forwardEventToSession(session.id, event);
+      }
+
+      if (abort.signal.aborted) return;
+
+      const aiSummary = lastAssistantText.slice(0, 500) || "Debug session completed (no text output)";
+      updateResultStatus(resultId, "done", { sessionId: session.id, aiSummary });
+
+      // Broadcast WS event + notification
+      this.broadcastStatusChange(resultId, result.issueKey, "done", session.id);
+
+      notificationService.broadcast("done", {
+        title: `Jira: ${result.issueKey}`,
+        body: aiSummary.slice(0, 200),
+        project: project.name,
+        sessionId: session.id,
+      }).catch(() => {});
+    } catch (e: any) {
+      if (!abort.signal.aborted) {
+        updateResultStatus(resultId, "failed", { aiSummary: e.message?.slice(0, 300) ?? "Unknown error" });
+        this.broadcastStatusChange(resultId, result.issueKey, "failed");
+      }
+    } finally {
+      this.cleanup(resultId, project.path);
+      this.processQueue();
+    }
+  }
+
+  private broadcastStatusChange(resultId: number, issueKey: string, status: string, sessionId?: string): void {
+    notificationService.broadcastWs({
+      type: "jira:status_change",
+      resultId, issueKey, status, sessionId,
+    }).catch(() => {});
+  }
+
+  // [C1 fix] Idempotent cleanup — safe to call multiple times
+  private cleanup(resultId: number, projectPath: string): void {
+    if (!this.active.has(resultId)) return; // already cleaned up
+    this.active.delete(resultId);
+    this.enqueuedIds.delete(resultId);
+    const count = (this.activeByProject.get(projectPath) ?? 1) - 1;
+    if (count <= 0) this.activeByProject.delete(projectPath);
+    else this.activeByProject.set(projectPath, count);
+  }
+}
+
+export const jiraDebugService = new JiraDebugSessionService();

package/src/services/jira-watcher-db.service.ts

@@ -0,0 +1,195 @@
+import { getDb } from "./db.service.ts";
+import type {
+  JiraWatcherRow, JiraWatchResultRow,
+  JiraWatcher, JiraWatchResult, JiraWatcherMode, JiraResultStatus,
+} from "../types/jira.ts";
+
+// ── Row → API mappers ─────────────────────────────────────────────────
+
+export function rowToWatcher(row: JiraWatcherRow): JiraWatcher {
+  return {
+    id: row.id,
+    jiraConfigId: row.jira_config_id,
+    name: row.name,
+    jql: row.jql,
+    promptTemplate: row.prompt_template,
+    enabled: row.enabled === 1,
+    mode: row.mode as JiraWatcherMode,
+    intervalMs: row.interval_ms,
+    lastPolledAt: row.last_polled_at,
+    createdAt: row.created_at,
+  };
+}
+
+export function rowToResult(row: JiraWatchResultRow): JiraWatchResult {
+  return {
+    id: row.id,
+    watcherId: row.watcher_id,
+    issueKey: row.issue_key,
+    issueSummary: row.issue_summary,
+    issueUpdated: row.issue_updated,
+    sessionId: row.session_id,
+    status: row.status,
+    aiSummary: row.ai_summary,
+    source: row.source,
+    readAt: row.read_at,
+    triggeredBy: row.triggered_by,
+    createdAt: row.created_at,
+  };
+}
+
+// ── Watcher CRUD ──────────────────────────────────────────────────────
+
+export function createWatcher(
+  configId: number, name: string, jql: string,
+  opts?: { promptTemplate?: string; intervalMs?: number; mode?: JiraWatcherMode },
+): JiraWatcher {
+  const result = getDb().query(`
+    INSERT INTO jira_watchers (jira_config_id, name, jql, prompt_template, interval_ms, mode)
+    VALUES (?, ?, ?, ?, ?, ?) RETURNING *
+  `).get(
+    configId, name, jql,
+    opts?.promptTemplate ?? null,
+    opts?.intervalMs ?? 120000,
+    opts?.mode ?? "debug",
+  ) as JiraWatcherRow;
+  return rowToWatcher(result);
+}
+
+export function updateWatcher(
+  id: number,
+  fields: Partial<{ name: string; jql: string; promptTemplate: string | null; intervalMs: number; enabled: boolean; mode: JiraWatcherMode }>,
+): JiraWatcher | null {
+  const sets: string[] = [];
+  const params: (string | number | null)[] = [];
+  if (fields.name !== undefined) { sets.push("name = ?"); params.push(fields.name); }
+  if (fields.jql !== undefined) { sets.push("jql = ?"); params.push(fields.jql); }
+  if (fields.promptTemplate !== undefined) { sets.push("prompt_template = ?"); params.push(fields.promptTemplate); }
+  if (fields.intervalMs !== undefined) { sets.push("interval_ms = ?"); params.push(fields.intervalMs); }
+  if (fields.enabled !== undefined) { sets.push("enabled = ?"); params.push(fields.enabled ? 1 : 0); }
+  if (fields.mode !== undefined) { sets.push("mode = ?"); params.push(fields.mode); }
+  if (sets.length === 0) return getWatcherById(id);
+  params.push(id);
+  getDb().query(`UPDATE jira_watchers SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getWatcherById(id);
+}
+
+export function deleteWatcher(id: number): boolean {
+  return getDb().query("DELETE FROM jira_watchers WHERE id = ?").run(id).changes > 0;
+}
+
+export function getWatcherById(id: number): JiraWatcher | null {
+  const row = getDb().query("SELECT * FROM jira_watchers WHERE id = ?").get(id) as JiraWatcherRow | null;
+  return row ? rowToWatcher(row) : null;
+}
+
+export function getWatchersByConfigId(configId: number): JiraWatcher[] {
+  const rows = getDb().query("SELECT * FROM jira_watchers WHERE jira_config_id = ? ORDER BY id")
+    .all(configId) as JiraWatcherRow[];
+  return rows.map(rowToWatcher);
+}
+
+export function getAllEnabledWatchers(): JiraWatcherRow[] {
+  return getDb().query("SELECT * FROM jira_watchers WHERE enabled = 1")
+    .all() as JiraWatcherRow[];
+}
+
+// ── Result CRUD ───────────────────────────────────────────────────────
+
+/** Insert a result. Resurrects soft-deleted duplicates. Returns true if row was inserted or resurrected. */
+export function insertResult(
+  watcherId: number | null, issueKey: string,
+  issueSummary: string | null, issueUpdated: string | null,
+  source: "watcher" | "manual" = "watcher",
+  triggeredBy: "auto" | "manual" = "auto",
+): { inserted: boolean; resultId: number | null } {
+  try {
+    const row = getDb().query(`
+      INSERT INTO jira_watch_results (watcher_id, issue_key, issue_summary, issue_updated, source, triggered_by)
+      VALUES (?, ?, ?, ?, ?, ?) RETURNING id
+    `).get(watcherId, issueKey, issueSummary, issueUpdated, source, triggeredBy) as { id: number } | null;
+    return { inserted: true, resultId: row?.id ?? null };
+  } catch (e: any) {
+    if (e.message?.includes("UNIQUE constraint")) {
+      // Resurrect soft-deleted row if it exists
+      const resurrected = getDb().query(`
+        UPDATE jira_watch_results
+        SET deleted = 0, status = 'pending', session_id = NULL, ai_summary = NULL,
+            read_at = NULL, triggered_by = ?, source = ?, created_at = datetime('now')
+        WHERE watcher_id IS ? AND issue_key = ? AND issue_updated IS ? AND deleted = 1
+        RETURNING id
+      `).get(triggeredBy, source, watcherId, issueKey, issueUpdated) as { id: number } | null;
+      if (resurrected) return { inserted: true, resultId: resurrected.id };
+      return { inserted: false, resultId: null };
+    }
+    throw e;
+  }
+}
+
+export function updateResultStatus(
+  resultId: number,
+  status: JiraResultStatus,
+  updates?: { sessionId?: string; aiSummary?: string },
+): void {
+  const sets = ["status = ?"];
+  const params: (string | number)[] = [status];
+  if (updates?.sessionId !== undefined) { sets.push("session_id = ?"); params.push(updates.sessionId); }
+  if (updates?.aiSummary !== undefined) { sets.push("ai_summary = ?"); params.push(updates.aiSummary); }
+  params.push(resultId);
+  getDb().query(`UPDATE jira_watch_results SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+
+export function getResultsByWatcherId(
+  watcherId?: number,
+  opts?: { status?: string; limit?: number; offset?: number; includeDeleted?: boolean },
+): JiraWatchResult[] {
+  const clauses: string[] = [];
+  const params: (string | number)[] = [];
+  if (watcherId !== undefined) { clauses.push("watcher_id = ?"); params.push(watcherId); }
+  if (opts?.status) { clauses.push("status = ?"); params.push(opts.status); }
+  if (!opts?.includeDeleted) clauses.push("deleted = 0");
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const limit = opts?.limit ?? 50;
+  const offset = opts?.offset ?? 0;
+  const rows = getDb()
+    .query(`SELECT * FROM jira_watch_results ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`)
+    .all(...params, limit, offset) as JiraWatchResultRow[];
+  return rows.map(rowToResult);
+}
+
+export function getResultById(id: number): JiraWatchResult | null {
+  const row = getDb().query("SELECT * FROM jira_watch_results WHERE id = ?")
+    .get(id) as JiraWatchResultRow | null;
+  return row ? rowToResult(row) : null;
+}
+
+export function softDeleteResult(id: number): boolean {
+  return getDb().query("UPDATE jira_watch_results SET deleted = 1 WHERE id = ?").run(id).changes > 0;
+}
+
+export function getRunningResults(): JiraWatchResultRow[] {
+  return getDb().query("SELECT * FROM jira_watch_results WHERE status = 'running'")
+    .all() as JiraWatchResultRow[];
+}
+
+export function getWatcherStats(): Record<JiraResultStatus, number> {
+  const rows = getDb().query(
+    "SELECT status, COUNT(*) as count FROM jira_watch_results WHERE deleted = 0 GROUP BY status",
+  ).all() as Array<{ status: JiraResultStatus; count: number }>;
+  const stats: Record<string, number> = { pending: 0, queued: 0, running: 0, done: 0, failed: 0 };
+  for (const r of rows) stats[r.status] = r.count;
+  return stats as Record<JiraResultStatus, number>;
+}
+
+export function markResultRead(resultId: number): boolean {
+  return getDb().query(
+    "UPDATE jira_watch_results SET read_at = datetime('now') WHERE id = ? AND read_at IS NULL",
+  ).run(resultId).changes > 0;
+}
+
+export function getUnreadCount(): number {
+  const row = getDb().query(
+    "SELECT COUNT(*) as count FROM jira_watch_results WHERE status = 'done' AND read_at IS NULL AND deleted = 0",
+  ).get() as { count: number };
+  return row.count;
+}

package/src/services/jira-watcher.service.ts

@@ -0,0 +1,159 @@
+import { searchIssues, JiraApiError, getRateLimitState } from "./jira-api-client.ts";
+import { getDecryptedCredentials } from "./jira-config.service.ts";
+import { getAllEnabledWatchers, insertResult } from "./jira-watcher-db.service.ts";
+import { jiraDebugService } from "./jira-debug-session.service.ts";
+import { getDb } from "./db.service.ts";
+import { notificationService } from "./notification.service.ts";
+import type { JiraWatcherRow, JiraIssue } from "../types/jira.ts";
+
+const INTERVAL_MIN = 30_000;   // 30s
+const INTERVAL_MAX = 3_600_000; // 60m
+const RATE_LIMIT_PAUSE_MS = 300_000; // 5min
+
+export function clampInterval(ms: number): number {
+  return Math.max(INTERVAL_MIN, Math.min(INTERVAL_MAX, ms));
+}
+
+class JiraWatcherService {
+  private activeTimers = new Map<number, Timer>();
+
+  async startAll(): Promise<void> {
+    const watchers = getAllEnabledWatchers();
+    for (const w of watchers) this.startWatcher(w.id, w.interval_ms);
+    if (watchers.length) console.log(`[jira] Started ${watchers.length} watcher(s)`);
+  }
+
+  stopAll(): void {
+    for (const [id, timer] of this.activeTimers) {
+      clearInterval(timer);
+      this.activeTimers.delete(id);
+    }
+  }
+
+  startWatcher(id: number, intervalMs: number): void {
+    if (this.activeTimers.has(id)) this.stopWatcher(id);
+    const interval = clampInterval(intervalMs);
+    const timer = setInterval(() => this.pollWatcher(id).catch((e) =>
+      console.warn(`[jira] Poll error watcher ${id}:`, e.message),
+    ), interval);
+    this.activeTimers.set(id, timer);
+  }
+
+  stopWatcher(id: number): void {
+    const timer = this.activeTimers.get(id);
+    if (timer) { clearInterval(timer); this.activeTimers.delete(id); }
+  }
+
+  isRunning(id: number): boolean {
+    return this.activeTimers.has(id);
+  }
+
+  async pollWatcher(watcherId: number, source: "auto" | "manual" = "auto"): Promise<number> {
+    const watcher = getDb()
+      .query("SELECT * FROM jira_watchers WHERE id = ?")
+      .get(watcherId) as JiraWatcherRow | null;
+    if (!watcher) return 0;
+
+    const creds = getDecryptedCredentials(watcher.jira_config_id);
+    if (!creds) { console.warn(`[jira] No credentials for config ${watcher.jira_config_id}`); return 0; }
+
+    // Check rate limit pause
+    const rlState = getRateLimitState(creds.baseUrl);
+    if (rlState.pausedUntil && Date.now() < rlState.pausedUntil) return 0;
+
+    const isFirstPoll = !watcher.last_polled_at;
+
+    try {
+      // First auto-poll = baseline only: just set last_polled_at, skip inserts
+      // Manual pull always fetches everything
+      if (isFirstPoll && source === "auto") {
+        await searchIssues(creds, watcher.jql); // validate JQL works
+        getDb().query("UPDATE jira_watchers SET last_polled_at = datetime('now') WHERE id = ?").run(watcherId);
+        console.log(`[jira] Watcher "${watcher.name}": baseline poll done (skipped inserts)`);
+        return 0;
+      }
+
+      const response = await searchIssues(creds, watcher.jql);
+      let newCount = 0;
+      const newResultIds: number[] = [];
+
+      for (const issue of response.issues) {
+        let inserted: boolean, resultId: number | null;
+        try {
+          ({ inserted, resultId } = insertResult(
+            watcher.id, issue.key,
+            issue.fields.summary, issue.fields.updated,
+            "watcher", source,
+          ));
+        } catch (e: any) {
+          console.error(`[jira] insertResult FK error for watcher ${watcher.id}, issue ${issue.key}:`, e.message);
+          throw e;
+        }
+        if (inserted && resultId) {
+          newCount++;
+          newResultIds.push(resultId);
+
+          if (watcher.mode === "notify") {
+            notificationService.broadcast("done", {
+              title: `Jira: ${issue.key}`,
+              body: issue.fields.summary,
+              project: "", sessionId: "",
+            }).catch(() => {});
+          }
+        }
+      }
+
+      // Auto-enqueue debug for new issues (≤5 to avoid flooding)
+      if (watcher.mode === "debug" && source === "auto" && newResultIds.length > 0 && newResultIds.length <= 5) {
+        for (const rid of newResultIds) {
+          try { jiraDebugService.enqueue(rid); } catch (e: any) {
+            console.warn(`[jira] enqueue debug error resultId=${rid}:`, e.message);
+          }
+        }
+      }
+
+      // Update last_polled_at
+      getDb().query("UPDATE jira_watchers SET last_polled_at = datetime('now') WHERE id = ?").run(watcherId);
+      if (newCount) console.log(`[jira] Watcher "${watcher.name}": ${newCount} new issue(s)`);
+      return newCount;
+    } catch (e) {
+      if (e instanceof JiraApiError && e.status === 429) {
+        console.warn(`[jira] Rate limited — pausing watchers for config ${watcher.jira_config_id}`);
+        this.pauseConfigWatchers(watcher.jira_config_id);
+      }
+      throw e;
+    }
+  }
+
+  // ── Internal helpers ──────────────────────────────────────────────
+
+  buildPrompt(watcher: JiraWatcherRow, issue: JiraIssue): string {
+    if (watcher.prompt_template) {
+      return watcher.prompt_template
+        .replace(/\{issue_key\}/g, issue.key)
+        .replace(/\{summary\}/g, issue.fields.summary)
+        .replace(/\{description\}/g, issue.fields.description ?? "(no description)")
+        .replace(/\{status\}/g, issue.fields.status.name)
+        .replace(/\{priority\}/g, issue.fields.priority?.name ?? "None");
+    }
+    return `Debug Jira issue ${issue.key}: ${issue.fields.summary}\n\nDescription:\n${issue.fields.description ?? "(no description)"}`;
+  }
+
+  private pauseConfigWatchers(configId: number): void {
+    const watchers = getDb()
+      .query("SELECT id FROM jira_watchers WHERE jira_config_id = ? AND enabled = 1")
+      .all(configId) as Array<{ id: number }>;
+    for (const w of watchers) this.stopWatcher(w.id);
+    // Re-start after pause
+    setTimeout(() => {
+      for (const w of watchers) {
+        const row = getDb().query("SELECT * FROM jira_watchers WHERE id = ? AND enabled = 1")
+          .get(w.id) as JiraWatcherRow | null;
+        if (row) this.startWatcher(row.id, row.interval_ms);
+      }
+    }, RATE_LIMIT_PAUSE_MS);
+  }
+
+}
+
+export const jiraWatcherService = new JiraWatcherService();

package/src/services/notification.service.ts

@@ -13,6 +13,12 @@ export interface NotificationPayload {
 }
 
 class NotificationService {
+  /** Broadcast event to all connected WebSocket clients */
+  async broadcastWs(event: unknown): Promise<void> {
+    const { broadcastGlobalEvent } = await import("../server/ws/chat.ts");
+    broadcastGlobalEvent(event);
+  }
+
   /** Broadcast notification to all channels (push, telegram). Fire-and-forget. */
   async broadcast(_type: NotificationType, payload: NotificationPayload): Promise<void> {
     const tasks: Promise<void>[] = [];