@adriandmitroca/relay 0.0.2

package/src/daemon.ts

@@ -0,0 +1,1096 @@
+import { loadConfig, allProjects, findProjectConfig, type Config, type ProjectConfig, type WorkspaceConfig } from "./config.ts";
+import { IssueDB, ConfigDB, type IssueRow, type IssueStatus } from "./db.ts";
+import { PriorityQueue } from "./queue.ts";
+import { SentryAdapter } from "./sources/sentry.ts";
+import { AsanaAdapter } from "./sources/asana.ts";
+import { LinearAdapter } from "./sources/linear.ts";
+import { JiraAdapter } from "./sources/jira.ts";
+import type { NormalizedIssue, Severity, SourceAdapter } from "./sources/types.ts";
+import { triageIssue } from "./worker/triage.ts";
+import { fixIssue } from "./worker/fix.ts";
+import type { ClaudeStreamEvent } from "./worker/claude.ts";
+import { createWorktree, removeWorktree, pushBranch, buildPRUrl } from "./worker/git.ts";
+import { TelegramBot } from "./notifications/telegram.ts";
+import { type CallbackAction, type CallbackData } from "./constants.ts";
+import { DashboardServer } from "./dashboard.ts";
+import { logger, setLogLevel, setLogFile } from "./utils/logger.ts";
+import { esc } from "./utils/html.ts";
+import { join, dirname } from "node:path";
+
+interface WorkspaceRuntime {
+  config: WorkspaceConfig;
+  telegram: TelegramBot | null;
+  adapters: Map<string, SourceAdapter>;
+}
+
+interface PipelineItem {
+  issue: NormalizedIssue;
+  row: IssueRow;
+  project: ProjectConfig;
+  adapter: SourceAdapter | null;
+  workspaceKey: string;
+}
+
+export interface ActionResult {
+  ok: boolean;
+  error?: string;
+  issue?: IssueRow;
+}
+
+export class Daemon {
+  private config!: Config;
+  private db!: IssueDB;
+  private configDB!: ConfigDB;
+  private queue!: PriorityQueue<PipelineItem>;
+  private workspaces: Map<string, WorkspaceRuntime> = new Map();
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private configWatcher: ReturnType<typeof import("node:fs").watch> | null = null;
+  private stopping = false;
+  private configPath: string;
+  private dashboard!: DashboardServer;
+  private baseDir: string;
+
+  constructor(configPath: string) {
+    this.configPath = configPath;
+    this.baseDir = dirname(configPath);
+  }
+
+  async start() {
+    // Init DB
+    const dbPath = join(this.baseDir, "sqlite.db");
+    this.db = new IssueDB(dbPath);
+    this.configDB = new ConfigDB(this.db.getDatabase());
+
+    // Auto-import config.json if DB has no config
+    if (!this.configDB.hasConfig()) {
+      const configFile = Bun.file(this.configPath);
+      if (await configFile.exists()) {
+        const jsonConfig = await loadConfig(this.configPath);
+        this.configDB.importFromJson(jsonConfig);
+        logger.info("Auto-imported config.json into database");
+      }
+    }
+
+    // Start dashboard (always — even without config for setup wizard)
+    const isDev = process.env.DEV === "1";
+    // Resolve dist/ relative to this source file so it works both in-repo and when
+    // installed globally via npm (where cwd != package root).
+    const distDir = join(dirname(import.meta.dir), "dist");
+    this.dashboard = new DashboardServer(this.db);
+    this.dashboard.setConfigDB(this.configDB);
+    this.dashboard.setConfigChangeHandler(() => this.reloadFromDB());
+    this.dashboard.setActionHandler((data) => this.executeAction(data));
+    this.dashboard.setStatusProvider(() => this.getIntegrationsStatus());
+    if (!isDev && await Bun.file(join(distDir, "index.html")).exists()) {
+      this.dashboard.setDistDir(distDir);
+    }
+    this.dashboard.start();
+
+    // If no config at all, wait for setup via dashboard
+    if (!this.configDB.hasConfig()) {
+      logger.info("No config found — dashboard running at http://localhost:7842/setup");
+      if (!isDev) await this.openBrowser();
+      this.setupShutdownHandlers();
+      return;
+    }
+
+    // Load config from DB
+    this.config = this.configDB.toConfig();
+    setLogLevel(this.config.logLevel);
+
+    // Preflight checks
+    await this.preflight();
+
+    const stuckIssues = this.db.resetStuckIssues();
+
+    // Init per-workspace runtimes
+    this.initWorkspaces();
+
+    // Notify topics of interrupted issues
+    for (const row of stuckIssues) {
+      if (!row.telegramThreadId) continue;
+      const ws = this.getWorkspaceRuntime(row.workspaceKey);
+      if (!ws?.telegram) continue;
+      const msg = row.status === "working"
+        ? "⏸ Interrupted — waiting for confirmation to restart"
+        : "🔄 Interrupted — re-triaging automatically...";
+      await ws.telegram.sendThreadMessage(row.telegramThreadId, msg);
+    }
+
+    // Init queue
+    this.queue = new PriorityQueue(this.config.maxConcurrency, (item) => this.processItem(item));
+
+    // Re-send pending approvals
+    await this.resendPendingApprovals();
+
+    // Run first poll
+    await this.poll();
+
+    // Start poll interval
+    this.pollTimer = setInterval(() => this.poll(), this.config.pollIntervalSeconds * 1000);
+
+    // Watch config.json for hot reload (legacy support)
+    this.watchConfig();
+
+    // Setup shutdown handlers
+    this.setupShutdownHandlers();
+
+    const projects = allProjects(this.config);
+    logger.info("Daemon started", {
+      workspaces: this.config.workspaces.length,
+      projects: projects.length,
+      pollInterval: `${this.config.pollIntervalSeconds}s`,
+      maxConcurrency: this.config.maxConcurrency,
+    });
+
+  }
+
+  private setupShutdownHandlers() {
+    const shutdown = async () => {
+      await this.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+
+  private async openBrowser() {
+    try {
+      const url = "http://localhost:7842";
+      if (process.platform === "darwin") {
+        await Bun.$`open ${url}`.quiet().nothrow();
+      } else {
+        await Bun.$`xdg-open ${url}`.quiet().nothrow();
+      }
+    } catch {}
+  }
+
+  async reloadFromDB() {
+    try {
+      const newConfig = this.configDB.toConfig();
+
+      // First-time config after setup wizard
+      if (!this.config && newConfig.workspaces.length > 0) {
+        this.config = newConfig;
+        setLogLevel(this.config.logLevel);
+        await this.preflight();
+        this.initWorkspaces();
+        this.queue = new PriorityQueue(this.config.maxConcurrency, (item) => this.processItem(item));
+        await this.poll();
+        this.pollTimer = setInterval(() => this.poll(), this.config.pollIntervalSeconds * 1000);
+        logger.info("Config loaded from setup wizard, daemon fully started");
+        return;
+      }
+
+      if (!this.config) return;
+
+      // Restart poll timer if interval changed
+      if (newConfig.pollIntervalSeconds !== this.config.pollIntervalSeconds) {
+        if (this.pollTimer) clearInterval(this.pollTimer);
+        this.pollTimer = setInterval(() => this.poll(), newConfig.pollIntervalSeconds * 1000);
+        logger.info("Poll interval updated", { seconds: newConfig.pollIntervalSeconds });
+      }
+
+      if (newConfig.logLevel !== this.config.logLevel) {
+        setLogLevel(newConfig.logLevel);
+        logger.info("Log level updated", { level: newConfig.logLevel });
+      }
+
+      // Reinit workspaces if workspace config changed
+      const oldWsJson = JSON.stringify(this.config.workspaces);
+      const newWsJson = JSON.stringify(newConfig.workspaces);
+      if (oldWsJson !== newWsJson) {
+        for (const ws of this.workspaces.values()) {
+          ws.telegram?.stopPolling();
+        }
+        this.workspaces.clear();
+        this.config = newConfig;
+        this.initWorkspaces();
+        logger.info("Workspaces reinitialized");
+      } else {
+        this.config = newConfig;
+      }
+
+      logger.info("Config reloaded from DB");
+      await this.poll();
+    } catch (err) {
+      logger.error("Config reload from DB failed", { error: String(err) });
+    }
+  }
+
+  async stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    logger.info("Shutting down...");
+
+    if (this.configWatcher) {
+      this.configWatcher.close();
+      this.configWatcher = null;
+    }
+
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+
+    for (const ws of this.workspaces.values()) {
+      ws.telegram?.stopPolling();
+    }
+
+    await this.queue.drain(10_000);
+    this.dashboard.stop();
+    this.db.close();
+
+    logger.info("Daemon stopped");
+  }
+
+  private async preflight() {
+    // Check repos exist
+    for (const { project: p } of allProjects(this.config)) {
+      const gitDir = Bun.file(join(p.repoPath, ".git"));
+      if (!(await gitDir.exists())) {
+        const stat = await Bun.$`test -d ${p.repoPath}`.quiet().nothrow();
+        if (stat.exitCode !== 0) {
+          throw new Error(`Repo path does not exist: ${p.repoPath}`);
+        }
+      }
+    }
+
+    // Check claude is installed
+    const claude = await Bun.$`which claude`.quiet().nothrow();
+    if (claude.exitCode !== 0) {
+      throw new Error("'claude' CLI not found in PATH. Install Claude Code first.");
+    }
+
+    // Check gh is installed and authenticated
+    const gh = await Bun.$`gh auth status`.quiet().nothrow();
+    if (gh.exitCode !== 0) {
+      throw new Error("'gh' CLI not authenticated. Run 'gh auth login' first.");
+    }
+  }
+
+  private initWorkspaces() {
+    // Share Telegram bot instances across workspaces with the same bot token
+    const telegramBots = new Map<string, TelegramBot>();
+
+    for (const wsConfig of this.config.workspaces) {
+      const adapters = new Map<string, SourceAdapter>();
+
+      let sentryAdapter: SentryAdapter | null = null;
+      let asanaAdapter: AsanaAdapter | null = null;
+      let linearAdapter: LinearAdapter | null = null;
+      let jiraAdapter: JiraAdapter | null = null;
+
+      for (const project of wsConfig.projects) {
+        if (project.sources.sentry) {
+          if (!sentryAdapter) {
+            sentryAdapter = new SentryAdapter(project.sources.sentry.authToken);
+            adapters.set("sentry", sentryAdapter);
+          }
+          sentryAdapter.addProject(project.key, project.sources.sentry);
+        }
+
+        if (project.sources.asana) {
+          if (!asanaAdapter) {
+            asanaAdapter = new AsanaAdapter(project.sources.asana.accessToken);
+            adapters.set("asana", asanaAdapter);
+          }
+          asanaAdapter.addProject(project.key, project.sources.asana);
+        }
+
+        if (project.sources.linear) {
+          if (!linearAdapter) {
+            linearAdapter = new LinearAdapter(project.sources.linear.apiKey);
+            adapters.set("linear", linearAdapter);
+          }
+          linearAdapter.addProject(project.key, project.sources.linear);
+        }
+
+        if (project.sources.jira) {
+          if (!jiraAdapter) {
+            jiraAdapter = new JiraAdapter();
+            adapters.set("jira", jiraAdapter);
+          }
+          jiraAdapter.addProject(project.key, project.sources.jira);
+        }
+      }
+
+      let telegram: TelegramBot | null = null;
+      if (wsConfig.telegram) {
+        telegram = telegramBots.get(wsConfig.telegram.botToken) ?? null;
+        if (!telegram) {
+          telegram = new TelegramBot(wsConfig.telegram.botToken, wsConfig.telegram.chatId);
+          telegram.startPolling();
+          telegramBots.set(wsConfig.telegram.botToken, telegram);
+        }
+        telegram.setCallbackHandler((data) => this.handleCallback(data, wsConfig.key));
+      }
+
+      this.workspaces.set(wsConfig.key, { config: wsConfig, telegram, adapters });
+    }
+  }
+
+  private watchConfig() {
+    const { watch } = require("node:fs") as typeof import("node:fs");
+    let debounce: ReturnType<typeof setTimeout> | null = null;
+
+    this.configWatcher = watch(this.configPath, () => {
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(() => this.reloadConfig(), 500);
+    });
+
+    logger.debug("Watching config for changes", { path: this.configPath });
+  }
+
+  private async reloadConfig() {
+    try {
+      const newConfig = await loadConfig(this.configPath);
+
+      // Restart poll timer if interval changed
+      if (newConfig.pollIntervalSeconds !== this.config.pollIntervalSeconds) {
+        if (this.pollTimer) clearInterval(this.pollTimer);
+        this.pollTimer = setInterval(() => this.poll(), newConfig.pollIntervalSeconds * 1000);
+        logger.info("Poll interval updated", { seconds: newConfig.pollIntervalSeconds });
+      }
+
+      if (newConfig.logLevel !== this.config.logLevel) {
+        setLogLevel(newConfig.logLevel);
+        logger.info("Log level updated", { level: newConfig.logLevel });
+      }
+
+      // Reinit workspaces if workspace config changed
+      const oldWsJson = JSON.stringify(this.config.workspaces);
+      const newWsJson = JSON.stringify(newConfig.workspaces);
+      if (oldWsJson !== newWsJson) {
+        for (const ws of this.workspaces.values()) {
+          ws.telegram?.stopPolling();
+        }
+        this.workspaces.clear();
+        this.config = newConfig;
+        this.initWorkspaces();
+        logger.info("Workspaces reinitialized");
+      } else {
+        this.config = newConfig;
+      }
+
+      logger.info("Config reloaded");
+
+      // Trigger immediate poll after reload
+      await this.poll();
+    } catch (err) {
+      logger.error("Config reload failed, keeping current config", { error: String(err) });
+    }
+  }
+
+  private async poll() {
+    if (this.stopping) return;
+
+    for (const [wsKey, ws] of this.workspaces) {
+      for (const project of ws.config.projects) {
+        for (const [name, adapter] of ws.adapters) {
+          try {
+            const issues = await adapter.poll(project.key);
+            let newCount = 0;
+
+            for (const issue of issues) {
+              if (this.db.exists(issue.source, issue.sourceId)) continue;
+
+              const row = this.db.upsert({ ...issue, workspaceKey: wsKey });
+              const enqueued = this.queue.enqueue(
+                `${issue.source}:${issue.sourceId}`,
+                { issue, row, project, adapter, workspaceKey: wsKey },
+                issue.severity as Severity,
+              );
+              if (enqueued) newCount++;
+            }
+
+            if (newCount > 0) {
+              logger.info("New issues found", { workspace: wsKey, source: name, project: project.key, count: newCount });
+            }
+          } catch (err) {
+            logger.error("Poll error", { workspace: wsKey, source: name, project: project.key, error: String(err) });
+          }
+        }
+      }
+    }
+
+    // Pick up manually queued entries
+    await this.processManualEntries();
+  }
+
+  private async processManualEntries() {
+    const newEntries = [...this.db.getByStatus("new"), ...this.db.getByStatus("triaged_actionable")];
+    for (const row of newEntries) {
+      const found = findProjectConfig(this.config, row.projectKey);
+      if (!found) {
+        logger.warn("Manual entry references unknown project", { projectKey: row.projectKey, id: row.id });
+        continue;
+      }
+
+      const ws = this.getWorkspaceRuntime(row.workspaceKey);
+      if (!ws) {
+        logger.warn("Manual entry references unknown workspace", { workspaceKey: row.workspaceKey, id: row.id });
+        continue;
+      }
+
+      const issue: NormalizedIssue = this.rowToIssue(row);
+      const adapter = ws.adapters.get(row.source) ?? null;
+
+      const enqueued = this.queue.enqueue(
+        `${row.source}:${row.sourceId}`,
+        { issue, row, project: found.project, adapter, workspaceKey: row.workspaceKey },
+        issue.severity as Severity,
+      );
+
+      if (enqueued) {
+        logger.info("Enqueued manual entry", { source: row.source, id: row.sourceId, project: row.projectKey });
+      }
+    }
+  }
+
+  private async loadProjectContext(repoPath: string): Promise<string | undefined> {
+    const candidates = ["CLAUDE.md", ".claude/CLAUDE.md", "AGENTS.md"];
+    for (const name of candidates) {
+      const file = Bun.file(join(repoPath, name));
+      if (await file.exists()) {
+        const content = await file.text();
+        return content.slice(0, 4000);
+      }
+    }
+    return undefined;
+  }
+
+  private dbUpdate(id: number, fields: Partial<Record<string, unknown>>) {
+    this.db.update(id, fields);
+    if (fields.status !== undefined) {
+      const row = this.db.getById(id);
+      if (row) this.dashboard.broadcast({ type: "issue_update", issue: row });
+    }
+  }
+
+  private dbUpdateStatus(id: number, status: IssueStatus) {
+    this.db.updateStatus(id, status);
+    const row = this.db.getById(id);
+    if (row) this.dashboard.broadcast({ type: "issue_update", issue: row });
+  }
+
+  private getWorkspaceRuntime(workspaceKey: string): WorkspaceRuntime | undefined {
+    return this.workspaces.get(workspaceKey);
+  }
+
+  private createStreamReporter(ws: WorkspaceRuntime, issueId: number, progressMsgId: number | null, stage: "triage" | "fix") {
+    let lastUpdate = 0;
+    const THROTTLE_MS = 3000;
+    const startTime = Date.now();
+    let toolCallCount = 0;
+    let lastTool = "";
+    let costUsd: number | undefined;
+
+    const icon = stage === "triage" ? "🔍" : "⚡";
+    const label = stage === "triage" ? "Triaging" : "Working";
+
+    return (event: ClaudeStreamEvent) => {
+      if (event.type === "tool_use") {
+        toolCallCount++;
+        lastTool = event.tool;
+      } else if (event.type === "text") {
+        // Broadcast text events immediately (no throttle) for live output
+        this.dashboard.broadcast({
+          type: "stream_text",
+          issueId,
+          stage,
+          text: event.text,
+        });
+        return;
+      } else if (event.type === "result" && "costUsd" in event) {
+        costUsd = (event as { costUsd?: number }).costUsd;
+      } else {
+        return;
+      }
+
+      const now = Date.now();
+      if (now - lastUpdate < THROTTLE_MS) return;
+      lastUpdate = now;
+
+      const elapsed = Math.round((now - startTime) / 1000);
+
+      // Broadcast to web dashboard
+      this.dashboard.broadcast({
+        type: "stream_progress",
+        issueId,
+        stage,
+        tool: lastTool,
+        elapsed,
+        toolCallCount,
+        startedAt: startTime,
+      });
+
+      // Update Telegram if available
+      if (ws.telegram && progressMsgId) {
+        let text = `${icon} <b>${label}...</b> ${lastTool} (${elapsed}s · ${toolCallCount} calls`;
+        if (costUsd != null) text += ` · ~$${costUsd.toFixed(3)}`;
+        text += `)`;
+        ws.telegram.editMessage(progressMsgId, text).catch(() => {});
+      }
+    };
+  }
+
+  private async processItem(item: PipelineItem) {
+    const { issue, row, project, adapter, workspaceKey } = item;
+    const ws = this.getWorkspaceRuntime(workspaceKey);
+    if (!ws) {
+      logger.error("Workspace runtime not found", { workspaceKey });
+      return;
+    }
+
+    const logCtx = { workspace: workspaceKey, source: issue.source, id: issue.sourceId, title: issue.title };
+
+    // Set triaging status early so the UI updates immediately
+    if (row.triageVerdict !== "fixable") {
+      this.dbUpdateStatus(row.id, "triaging");
+    }
+
+    // Reuse existing topic or create new one
+    let threadId = row.telegramThreadId;
+    if (ws.telegram) {
+      if (threadId) {
+        await ws.telegram.reopenThread(threadId);
+        const retryMsg = row.status === "triaged_actionable" && row.triageVerdict === "fixable"
+          ? "⚙️ Starting..."
+          : "🔄 Retrying...";
+        await ws.telegram.sendThreadMessage(threadId, retryMsg);
+      } else {
+        threadId = await ws.telegram.createIssueTopic(row);
+        if (threadId) {
+          this.dbUpdate(row.id, { telegramThreadId: threadId });
+        } else {
+          logger.warn("Failed to create forum topic, continuing without Telegram", logCtx);
+        }
+      }
+    }
+
+    try {
+      const projectContext = await this.loadProjectContext(project.repoPath);
+      const context = adapter
+        ? await adapter.getIssueContext(issue)
+        : `Task: ${issue.title}\n\n${issue.body || "Investigate and address the issue described in the title."}`;
+
+      // Skip triage if already triaged as fixable (e.g. user clicked "Start Fix")
+      if (row.triageVerdict === "fixable") {
+        logger.info("Skipping triage, already triaged as fixable", logCtx);
+        this.dbUpdateStatus(row.id, "triaged_actionable");
+        await this.fixStage(row, issue, project, context, projectContext, ws, threadId, logCtx, { plan: row.triagePlan, sessionId: row.sessionId ?? undefined });
+        return;
+      }
+
+      await this.triageStage(row, issue, project, context, projectContext, ws, threadId, logCtx);
+    } catch (err) {
+      logger.error("Pipeline error", { ...logCtx, error: String(err) });
+      this.dbUpdate(row.id, { status: "failed", fixSummary: String(err), failureReason: "pipeline:unexpected" });
+      if (ws.telegram && threadId) {
+        const msgId = await ws.telegram.sendFailedMessage(row.source, row.sourceId, String(err).slice(0, 500), threadId, "pipeline:unexpected");
+        if (msgId) this.dbUpdate(row.id, { telegramMessageId: msgId });
+      }
+    }
+  }
+
+  private async pendingConfirmation(rowId: number, row: IssueRow, threadId: number | null, ws: WorkspaceRuntime) {
+    if (ws.telegram && threadId) {
+      const msgId = await ws.telegram.sendFixReady(row, threadId);
+      if (msgId) this.db.update(rowId, { telegramMessageId: msgId });
+    }
+    this.queue.pause();
+  }
+
+  private async triageStage(
+    row: IssueRow,
+    issue: NormalizedIssue,
+    project: ProjectConfig,
+    context: string,
+    projectContext: string | undefined,
+    ws: WorkspaceRuntime,
+    threadId: number | null,
+    logCtx: Record<string, string>,
+  ): Promise<void> {
+    if (!this.config.triage) {
+      logger.info("Triage disabled, awaiting fix confirmation", logCtx);
+      this.dbUpdate(row.id, { status: "pending_confirmation", triageVerdict: "fixable" });
+      const updatedRow = this.db.get(issue.source, issue.sourceId)!;
+      await this.pendingConfirmation(row.id, updatedRow, threadId, ws);
+      return;
+    }
+
+    logger.info("Triaging issue", logCtx);
+
+    const triageMsgId = ws.telegram && threadId
+      ? await ws.telegram.sendThreadMessage(threadId, "🔍 Triaging with Sonnet...")
+      : null;
+
+    const onEvent = this.createStreamReporter(ws, row.id, triageMsgId, "triage");
+
+    const triageLogPath = `/tmp/relay-${row.id}-triage.ndjson`;
+    const triage = await triageIssue(context, project.repoPath, this.config.triageTimeout, projectContext, "sonnet", onEvent, triageLogPath);
+
+    const triageStats = {
+      triageDurationMs: triage.durationMs,
+      triageInputTokens: triage.inputTokens,
+      triageOutputTokens: triage.outputTokens,
+      triageCostUsd: triage.costUsd ?? null,
+    };
+
+    if (triage.failed) {
+      logger.warn("Triage error", { ...logCtx, reason: triage.reason });
+      this.dbUpdate(row.id, { status: "failed", triageReason: triage.reason, failureReason: triage.failureReason, ...triageStats });
+      if (ws.telegram && threadId) {
+        const msgId = await ws.telegram.sendFailedMessage(row.source, row.sourceId, triage.reason, threadId, triage.failureReason);
+        if (msgId) this.dbUpdate(row.id, { telegramMessageId: msgId });
+      }
+      return;
+    }
+
+    this.dbUpdate(row.id, {
+      triageVerdict: triage.fixable ? "fixable" : "unfixable",
+      triageReason: triage.reason,
+      triagePlan: triage.plan,
+      triageConfidence: triage.confidence,
+      sessionId: triage.sessionId,
+      status: triage.fixable ? "pending_confirmation" : "triaged_not_actionable",
+      ...triageStats,
+    });
+
+    if (ws.telegram) {
+      const updatedRow = this.db.get(issue.source, issue.sourceId)!;
+      const triageResultMsgId = await ws.telegram.sendTriageResult(updatedRow, triage, threadId ?? undefined);
+      if (triageResultMsgId) {
+        this.dbUpdate(row.id, { telegramMessageId: triageResultMsgId });
+      }
+    }
+
+    if (!triage.fixable) {
+      logger.info("Issue not fixable", logCtx);
+      return;
+    }
+
+    logger.info("Triage fixable, awaiting fix confirmation — queue paused", logCtx);
+    this.queue.pause();
+  }
+
+  private async fixStage(
+    row: IssueRow,
+    issue: NormalizedIssue,
+    project: ProjectConfig,
+    context: string,
+    projectContext: string | undefined,
+    ws: WorkspaceRuntime,
+    threadId: number | null,
+    logCtx: Record<string, string>,
+    triage: { plan: string | null; sessionId?: string },
+  ) {
+    if (ws.telegram && threadId) {
+      await ws.telegram.sendThreadMessage(threadId, "🛠 Creating worktree...");
+    }
+    logger.info("Creating worktree", logCtx);
+    let worktreePath: string;
+    let branchName: string;
+    try {
+      ({ worktreePath, branchName } = await createWorktree(
+        project.repoPath,
+        issue.source,
+        issue.sourceId,
+        project.baseBranch,
+      ));
+    } catch (err) {
+      logger.error("Worktree creation failed", { ...logCtx, error: String(err) });
+      this.dbUpdate(row.id, { status: "failed", fixSummary: String(err), failureReason: "worktree:create_failed" });
+      if (ws.telegram && threadId) {
+        const msgId = await ws.telegram.sendFailedMessage(row.source, row.sourceId, String(err), threadId, "worktree:create_failed");
+        if (msgId) this.dbUpdate(row.id, { telegramMessageId: msgId });
+      }
+      return;
+    }
+
+    this.dbUpdate(row.id, { worktreePath, branch: branchName, status: "working" });
+
+    logger.info("Fixing issue", logCtx);
+
+    const fixMsgId = ws.telegram && threadId
+      ? await ws.telegram.sendThreadMessage(threadId, "⚡ Working with Opus...")
+      : null;
+
+    const onEvent = this.createStreamReporter(ws, row.id, fixMsgId, "fix");
+
+    const fixLogPath = `/tmp/relay-${row.id}-fix.ndjson`;
+    const fixResult = await fixIssue({
+      issueContext: context,
+      triagePlan: triage.plan ?? "Investigate the issue, find the root cause, and implement a fix.",
+      worktreePath,
+      baseBranch: project.baseBranch,
+      testCommand: project.testCommand,
+      claudeTimeout: this.config.claudeTimeout,
+      allowedTools: this.config.allowedTools,
+      projectContext,
+      model: "opus",
+      sessionId: triage.sessionId,
+      onEvent,
+      logPath: fixLogPath,
+    });
+
+    const fixStats = {
+      fixDurationMs: fixResult.durationMs,
+      fixInputTokens: fixResult.inputTokens,
+      fixOutputTokens: fixResult.outputTokens,
+      fixCostUsd: fixResult.costUsd ?? null,
+    };
+
+    if (!fixResult.success) {
+      logger.warn("Fix failed", { ...logCtx, error: fixResult.error });
+      this.dbUpdate(row.id, { status: "failed", fixSummary: fixResult.error, failureReason: fixResult.failureReason, ...fixStats });
+      await removeWorktree(project.repoPath, worktreePath, branchName);
+      if (ws.telegram && threadId) {
+        const msgId = await ws.telegram.sendFailedMessage(row.source, row.sourceId, fixResult.error ?? "unknown error", threadId, fixResult.failureReason);
+        if (msgId) this.dbUpdate(row.id, { telegramMessageId: msgId });
+      }
+      return;
+    }
+
+    this.dbUpdate(row.id, {
+      status: "pending_approval",
+      fixSummary: fixResult.summary,
+      diffSummary: fixResult.diffSummary,
+      diffPatch: fixResult.diffPatch,
+      ...fixStats,
+    });
+
+    if (ws.telegram) {
+      const approvalRow = this.db.get(issue.source, issue.sourceId)!;
+      const approvalMsgId = await ws.telegram.sendApproval(
+        approvalRow,
+        fixResult.summary,
+        threadId ?? undefined,
+        { durationMs: fixResult.durationMs, inputTokens: fixResult.inputTokens, outputTokens: fixResult.outputTokens, costUsd: fixResult.costUsd },
+      );
+      if (approvalMsgId) {
+        this.dbUpdate(row.id, { telegramMessageId: approvalMsgId });
+      }
+    }
+
+    logger.info("Fix ready, awaiting approval — queue paused", logCtx);
+    this.queue.pause();
+  }
+
+  async executeAction(data: CallbackData): Promise<ActionResult> {
+    const row = this.db.get(data.source, data.sourceId);
+    if (!row) {
+      return { ok: false, error: "Issue not found" };
+    }
+
+    const ws = this.getWorkspaceRuntime(row.workspaceKey);
+    if (!ws) {
+      return { ok: false, error: "Workspace not found" };
+    }
+
+    const found = findProjectConfig(this.config, row.projectKey);
+    if (!found) {
+      return { ok: false, error: "Project not found" };
+    }
+    const { project } = found;
+    const adapter = ws.adapters.get(row.source);
+    const threadId = row.telegramThreadId;
+
+    switch (data.action) {
+      case "accept": {
+        if (row.status !== "pending_approval") {
+          return { ok: false, error: `Cannot accept issue in status '${row.status}'` };
+        }
+
+        logger.info("Fix accepted", { source: row.source, id: row.sourceId });
+
+        let acceptFailureReason: string | undefined;
+        try {
+          try {
+            await pushBranch(row.worktreePath!, row.branch!);
+          } catch (err) {
+            acceptFailureReason = "accept:push_failed";
+            throw err;
+          }
+
+          let prUrl: string;
+          try {
+            const prBody = buildPRBody(row);
+            prUrl = await buildPRUrl(
+              row.worktreePath!,
+              row.branch!,
+              project.baseBranch,
+              `fix: ${row.title}`,
+              prBody,
+            );
+          } catch (err) {
+            acceptFailureReason = "accept:pr_failed";
+            throw err;
+          }
+
+          this.dbUpdate(row.id, { status: "accepted", prUrl });
+
+          await removeWorktree(project.repoPath, row.worktreePath!, row.branch!);
+
+          if (adapter && adapter.onFixAccepted) {
+            const issue = this.rowToIssue(row);
+            await adapter.onFixAccepted(issue, prUrl);
+          }
+
+          if (ws.telegram) {
+            if (row.telegramMessageId) {
+              await ws.telegram.editMessageRemoveKeyboard(
+                row.telegramMessageId,
+                `✅ <b>ACCEPTED</b> — ${esc(row.title)}`,
+              );
+            }
+            if (threadId) {
+              await ws.telegram.sendThreadMessage(threadId, `✅ <b>ACCEPTED</b>\n<a href="${esc(prUrl)}">Create PR</a>`);
+            }
+          }
+
+          this.queue.resume();
+          logger.info("Queue resumed");
+          return { ok: true, issue: this.db.getById(row.id)! };
+        } catch (err) {
+          logger.error("Accept failed", { error: String(err) });
+          this.dbUpdate(row.id, { status: "failed", failureReason: acceptFailureReason });
+          if (ws.telegram) {
+            if (row.telegramMessageId) {
+              await ws.telegram.editMessageRemoveKeyboard(
+                row.telegramMessageId,
+                `❌ <b>ACCEPT FAILED</b> — ${esc(row.title)}`,
+              );
+            }
+            if (threadId) {
+              const msgId = await ws.telegram.sendFailedMessage(row.source, row.sourceId, String(err), threadId, acceptFailureReason);
+              if (msgId) this.dbUpdate(row.id, { telegramMessageId: msgId });
+            }
+          }
+          this.queue.resume();
+          logger.info("Queue resumed");
+          return { ok: false, error: String(err) };
+        }
+      }
+
+      case "discard": {
+        logger.info("Fix discarded", { source: row.source, id: row.sourceId });
+        this.dbUpdate(row.id, { status: "discarded" });
+
+        if (row.worktreePath && row.branch) {
+          await removeWorktree(project.repoPath, row.worktreePath, row.branch);
+        }
+
+        if (adapter && adapter.onFixDiscarded) {
+          await adapter.onFixDiscarded(this.rowToIssue(row));
+        }
+
+        if (ws.telegram) {
+          if (row.telegramMessageId) {
+            await ws.telegram.editMessageRemoveKeyboard(
+              row.telegramMessageId,
+              `🗑 <b>DISCARDED</b> — ${esc(row.title)}`,
+            );
+          }
+          if (threadId) {
+            await ws.telegram.closeThread(threadId, `🗑 <b>DISCARDED</b> — ${esc(row.title)}`);
+          }
+        }
+        break;
+      }
+
+      case "skip": {
+        logger.info("Issue skipped", { source: row.source, id: row.sourceId });
+        this.dbUpdate(row.id, { status: "skipped" });
+
+        if (row.worktreePath && row.branch) {
+          await removeWorktree(project.repoPath, row.worktreePath, row.branch);
+        }
+
+        if (ws.telegram) {
+          if (row.telegramMessageId) {
+            await ws.telegram.editMessageRemoveKeyboard(
+              row.telegramMessageId,
+              `⏭ <b>SKIPPED</b> — ${esc(row.title)}`,
+            );
+          }
+          if (threadId) {
+            await ws.telegram.closeThread(threadId, `⏭ <b>SKIPPED</b> — ${esc(row.title)}`);
+          }
+        }
+        break;
+      }
+
+      case "retry": {
+        if (row.status !== "failed" && row.status !== "triaged_not_actionable") {
+          return { ok: false, error: `Cannot retry issue in status '${row.status}'` };
+        }
+
+        logger.info("Retrying issue", { source: row.source, id: row.sourceId });
+
+        if (ws.telegram && row.telegramMessageId) {
+          await ws.telegram.editMessageRemoveKeyboard(row.telegramMessageId, `🔄 Retrying...`);
+        }
+
+        if (row.triageVerdict === "fixable") {
+          // Triage already done — skip straight to fix confirmation
+          this.dbUpdateStatus(row.id, "pending_confirmation");
+          const freshRow = this.db.get(row.source, row.sourceId)!;
+          await this.pendingConfirmation(row.id, freshRow, threadId, ws);
+          // Skip queue.resume() — waiting for "Start Fix"
+          return { ok: true, issue: this.db.getById(row.id)! };
+        } else {
+          // Re-triage from scratch — clear stale triage data
+          this.dbUpdate(row.id, {
+            status: "new",
+            triageVerdict: null,
+            triageReason: null,
+            triagePlan: null,
+            triageConfidence: null,
+            sessionId: null,
+            failureReason: null,
+            triageDurationMs: null,
+            triageInputTokens: null,
+            triageOutputTokens: null,
+            triageCostUsd: null,
+          });
+          const freshRow = this.db.get(row.source, row.sourceId)!;
+          const retryIssue = this.rowToIssue(freshRow);
+          this.queue.enqueue(
+            `${row.source}:${row.sourceId}`,
+            { issue: retryIssue, row: freshRow, project, adapter: ws.adapters.get(row.source) ?? null, workspaceKey: row.workspaceKey },
+            retryIssue.severity as Severity,
+          );
+        }
+        break;
+      }
+
+      case "fix": {
+        if (row.status !== "pending_confirmation") {
+          return { ok: false, error: `Cannot start fix for issue in status '${row.status}'` };
+        }
+
+        logger.info("Fix confirmed, enqueuing", { source: row.source, id: row.sourceId });
+
+        if (ws.telegram && row.telegramMessageId) {
+          await ws.telegram.editMessageRemoveKeyboard(
+            row.telegramMessageId,
+            `🛠 <b>STARTED</b> — ${esc(row.title)}`,
+          );
+        }
+
+        this.dbUpdateStatus(row.id, "triaged_actionable");
+        const freshRow = this.db.get(row.source, row.sourceId)!;
+        const fixIssue = this.rowToIssue(freshRow);
+        this.queue.enqueue(
+          `${row.source}:${row.sourceId}`,
+          { issue: fixIssue, row: freshRow, project, adapter: ws.adapters.get(row.source) ?? null, workspaceKey: row.workspaceKey },
+          fixIssue.severity as Severity,
+        );
+        break;
+      }
+    }
+
+    // Resume queue after any callback action
+    this.queue.resume();
+    logger.info("Queue resumed");
+    return { ok: true, issue: this.db.getById(row.id)! };
+  }
+
+  private async handleCallback(data: CallbackData, workspaceKey: string) {
+    // Look up the issue to verify workspace
+    const row = this.db.get(data.source, data.sourceId);
+    if (!row) {
+      logger.warn("Callback for unknown issue", { action: data.action, source: data.source, sourceId: data.sourceId });
+      return;
+    }
+    await this.executeAction(data);
+  }
+
+  private async resendPendingApprovals() {
+    const pending = this.db.getByStatus("pending_approval");
+    const resent = pending.filter((row) => {
+      if (row.telegramMessageId) return false;
+      return row.telegramThreadId;
+    });
+
+    for (const row of resent) {
+      const ws = this.getWorkspaceRuntime(row.workspaceKey);
+      if (!ws?.telegram) continue;
+
+      const msgId = await ws.telegram.sendApproval(
+        row,
+        row.fixSummary ?? "",
+        row.telegramThreadId!,
+      );
+      if (msgId) {
+        this.dbUpdate(row.id, { telegramMessageId: msgId });
+      }
+    }
+    if (resent.length) {
+      logger.info("Re-sent pending approvals", { count: resent.length });
+    }
+  }
+
+  private rowToIssue(row: IssueRow): NormalizedIssue {
+    return {
+      source: row.source,
+      sourceId: row.sourceId,
+      externalUrl: row.externalUrl,
+      projectKey: row.projectKey,
+      title: row.title,
+      body: row.body,
+      severity: row.severity as Severity,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+    };
+  }
+
+  private getIntegrationsStatus(): Array<{ workspace: string; telegram: boolean; sources: string[] }> {
+    const result: Array<{ workspace: string; telegram: boolean; sources: string[] }> = [];
+    for (const [key, ws] of this.workspaces) {
+      result.push({
+        workspace: key,
+        telegram: ws.telegram !== null,
+        sources: [...ws.adapters.keys()],
+      });
+    }
+    return result;
+  }
+
+  getDB(): IssueDB {
+    return this.db;
+  }
+}
+
+function buildPRBody(row: IssueRow): string {
+  const lines: string[] = [];
+
+  if (row.externalUrl) {
+    lines.push("## Source");
+    lines.push(row.externalUrl);
+    lines.push("");
+  }
+
+  lines.push("## Summary");
+  lines.push(row.fixSummary ?? "Automated changes.");
+  lines.push("");
+
+  lines.push("## Test plan");
+  lines.push("- [ ] Verify the changes resolve the issue");
+  lines.push("- [ ] Run existing tests");
+  lines.push("- [ ] Manual QA");
+  lines.push("");
+
+  lines.push("---");
+  lines.push("🤖 Generated with [Claude Code](https://claude.com/claude-code) · Enhanced by [Relay](https://github.com/adriandmitroca/relay)");
+
+  return lines.join("\n");
+}
+
+// When run directly
+if (import.meta.main) {
+  const configPath = process.argv[2] || join(process.cwd(), "config.json");
+  const daemon = new Daemon(configPath);
+  await daemon.start();
+}