markupr 2.1.8 → 2.5.0

package/dist/mcp/index.mjs

@@ -0,0 +1,4053 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/mcp/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/mcp/tools/captureScreenshot.ts
+import { z } from "zod";
+import { join as join2 } from "path";
+import { readdir as readdir2 } from "fs/promises";
+
+// src/mcp/capture/ScreenCapture.ts
+import { execFile as execFileCb } from "child_process";
+import { stat } from "fs/promises";
+import { resolve } from "path";
+
+// src/mcp/utils/Logger.ts
+function log(message) {
+  process.stderr.write(`[markupr-mcp] ${message}
+`);
+}
+
+// src/mcp/capture/ScreenCapture.ts
+var SAFE_CHILD_ENV = {
+  PATH: process.env.PATH,
+  HOME: process.env.HOME || process.env.USERPROFILE,
+  USERPROFILE: process.env.USERPROFILE,
+  LANG: process.env.LANG,
+  TMPDIR: process.env.TMPDIR || process.env.TEMP,
+  TEMP: process.env.TEMP
+};
+async function capture(options) {
+  const display = options.display ?? 1;
+  const outputPath = resolve(options.outputPath);
+  const args = ["-x", `-D${display}`, outputPath];
+  log(`Capturing screenshot: display=${display}, output=${outputPath}`);
+  await new Promise((resolve4, reject) => {
+    execFileCb("screencapture", args, { env: SAFE_CHILD_ENV }, (error) => {
+      if (error) {
+        reject(
+          new Error(
+            `screencapture failed: ${error.message}
+Ensure Screen Recording permission is granted in System Settings \u2192 Privacy & Security \u2192 Screen Recording.`
+          )
+        );
+        return;
+      }
+      resolve4();
+    });
+  });
+  let fileStats;
+  try {
+    fileStats = await stat(outputPath);
+  } catch {
+    throw new Error(
+      `Screenshot file not created at ${outputPath}.
+Ensure Screen Recording permission is granted in System Settings \u2192 Privacy & Security \u2192 Screen Recording.`
+    );
+  }
+  if (!fileStats.isFile() || fileStats.size === 0) {
+    throw new Error(
+      "Screenshot captured but file is empty (0 bytes). This typically means Screen Recording permission is not granted.\nGrant permission in System Settings \u2192 Privacy & Security \u2192 Screen Recording."
+    );
+  }
+  log(`Screenshot captured: ${outputPath} (${fileStats.size} bytes)`);
+  return outputPath;
+}
+
+// src/mcp/utils/ImageOptimizer.ts
+import sharp from "sharp";
+import { resolve as resolve2 } from "path";
+var DEFAULT_MAX_WIDTH = 1920;
+var DEFAULT_QUALITY = 85;
+async function optimize(inputPath, outputPath, options) {
+  const resolvedInput = resolve2(inputPath);
+  const resolvedOutput = resolve2(outputPath ?? inputPath);
+  const maxWidth = options?.maxWidth ?? DEFAULT_MAX_WIDTH;
+  const quality = options?.quality ?? DEFAULT_QUALITY;
+  const metadata = await sharp(resolvedInput).metadata();
+  const originalWidth = metadata.width ?? 0;
+  const originalHeight = metadata.height ?? 0;
+  let pipeline = sharp(resolvedInput);
+  if (originalWidth > maxWidth) {
+    pipeline = pipeline.resize({ width: maxWidth, withoutEnlargement: true });
+    log(
+      `Resizing image: ${originalWidth}x${originalHeight} \u2192 max width ${maxWidth}px`
+    );
+  }
+  const ext = resolvedOutput.split(".").pop()?.toLowerCase();
+  if (ext === "jpg" || ext === "jpeg") {
+    pipeline = pipeline.jpeg({ quality });
+  } else {
+    pipeline = pipeline.png({ quality: Math.min(quality, 100) });
+  }
+  await pipeline.toFile(resolvedOutput);
+  log(`Image optimized: ${resolvedOutput}`);
+  return resolvedOutput;
+}
+
+// src/mcp/session/SessionStore.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+var BASE_DIR = path.join(os.homedir(), "Documents", "markupr", "mcp");
+var SessionStore = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? BASE_DIR;
+  }
+  /**
+   * Create a new session directory with metadata.json.
+   */
+  async create(label) {
+    await fs.mkdir(this.baseDir, { recursive: true });
+    const now = Date.now();
+    const id = this.formatSessionId(now);
+    const sessionDir = path.join(this.baseDir, id);
+    let finalDir = sessionDir;
+    let counter = 1;
+    while (await this.exists(finalDir)) {
+      finalDir = path.join(this.baseDir, `${id}-${counter}`);
+      counter++;
+    }
+    const finalId = path.basename(finalDir);
+    await fs.mkdir(finalDir, { recursive: true });
+    await fs.mkdir(path.join(finalDir, "screenshots"), { recursive: true });
+    const session = {
+      id: finalId,
+      startTime: now,
+      label,
+      status: "recording"
+    };
+    const metadata = { ...session };
+    await this.writeMetadata(finalDir, metadata);
+    log(`Session created: ${finalId}`);
+    return session;
+  }
+  /**
+   * Read a session's metadata by ID.
+   */
+  async get(id) {
+    const metadataPath = path.join(this.baseDir, id, "metadata.json");
+    try {
+      const raw = await fs.readFile(metadataPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Return the most recent session (by startTime).
+   */
+  async getLatest() {
+    const sessions = await this.list();
+    return sessions[0] ?? null;
+  }
+  /**
+   * List all sessions sorted by startTime descending.
+   */
+  async list() {
+    const sessions = [];
+    try {
+      await fs.access(this.baseDir);
+    } catch {
+      return sessions;
+    }
+    let entries;
+    try {
+      entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+    } catch {
+      return sessions;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const metadataPath = path.join(this.baseDir, entry.name, "metadata.json");
+      try {
+        const raw = await fs.readFile(metadataPath, "utf-8");
+        const session = JSON.parse(raw);
+        sessions.push(session);
+      } catch {
+      }
+    }
+    sessions.sort((a, b) => b.startTime - a.startTime);
+    return sessions;
+  }
+  /**
+   * Update a session's metadata (partial merge).
+   */
+  async update(id, data) {
+    const sessionDir = path.join(this.baseDir, id);
+    const metadataPath = path.join(sessionDir, "metadata.json");
+    let existing;
+    try {
+      const raw = await fs.readFile(metadataPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {
+      throw new Error(`Session not found: ${id}`);
+    }
+    const updated = { ...existing, ...data };
+    await this.writeMetadata(sessionDir, updated);
+    log(`Session updated: ${id}`);
+  }
+  /**
+   * Get the absolute path to a session directory.
+   */
+  getSessionDir(id) {
+    return path.join(this.baseDir, id);
+  }
+  /**
+   * Format a timestamp into the session ID pattern: mcp-YYYYMMDD-HHMMSS
+   */
+  formatSessionId(timestamp) {
+    const date = new Date(timestamp);
+    const dateStr = [
+      date.getFullYear(),
+      String(date.getMonth() + 1).padStart(2, "0"),
+      String(date.getDate()).padStart(2, "0")
+    ].join("");
+    const timeStr = [
+      String(date.getHours()).padStart(2, "0"),
+      String(date.getMinutes()).padStart(2, "0"),
+      String(date.getSeconds()).padStart(2, "0")
+    ].join("");
+    return `mcp-${dateStr}-${timeStr}`;
+  }
+  async writeMetadata(sessionDir, metadata) {
+    const metadataPath = path.join(sessionDir, "metadata.json");
+    await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+  }
+  async exists(dir) {
+    try {
+      await fs.access(dir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var sessionStore = new SessionStore();
+
+// src/mcp/tools/captureScreenshot.ts
+function register(server) {
+  server.tool(
+    "capture_screenshot",
+    "Take a screenshot of the current screen, optimize it, and save to the session directory. Returns a markdown image reference.",
+    {
+      label: z.string().optional().describe("Optional label for the screenshot"),
+      display: z.number().optional().default(1).describe("Display number (1-indexed)"),
+      optimize: z.boolean().optional().default(true).describe("Optimize image size with sharp")
+    },
+    async ({ label, display, optimize: shouldOptimize }) => {
+      try {
+        const session = await sessionStore.create(label);
+        const sessionDir = sessionStore.getSessionDir(session.id);
+        const screenshotsDir = join2(sessionDir, "screenshots");
+        const existing = await readdir2(screenshotsDir).catch(() => []);
+        const index = existing.filter((f) => f.startsWith("screenshot-")).length + 1;
+        const filename = `screenshot-${String(index).padStart(3, "0")}.png`;
+        const outputPath = join2(screenshotsDir, filename);
+        log(`Capturing screenshot: display=${display}, label=${label ?? "none"}`);
+        await capture({ display, outputPath });
+        if (shouldOptimize) {
+          await optimize(outputPath);
+        }
+        const markdownRef = `![${label ?? filename}](screenshots/${filename})`;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Screenshot saved: ${outputPath}
+${markdownRef}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/captureWithVoice.ts
+import { z as z2 } from "zod";
+import { join as join6 } from "path";
+
+// src/mcp/capture/ScreenRecorder.ts
+import { execFile as execFileCb2 } from "child_process";
+import { stat as stat2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+var SAFE_CHILD_ENV2 = {
+  PATH: process.env.PATH,
+  HOME: process.env.HOME || process.env.USERPROFILE,
+  USERPROFILE: process.env.USERPROFILE,
+  LANG: process.env.LANG,
+  TMPDIR: process.env.TMPDIR || process.env.TEMP,
+  TEMP: process.env.TEMP
+};
+function buildFfmpegArgs(outputPath, videoDevice, audioDevice, duration) {
+  const input = `${videoDevice}:${audioDevice}`;
+  const args = [
+    "-f",
+    "avfoundation",
+    "-framerate",
+    "10",
+    "-i",
+    input,
+    "-vcodec",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-acodec",
+    "aac",
+    "-strict",
+    "experimental"
+  ];
+  if (duration !== void 0) {
+    args.push("-t", String(duration));
+  }
+  args.push("-y", outputPath);
+  return args;
+}
+async function record(options) {
+  const { duration } = options;
+  const outputPath = resolve3(options.outputPath);
+  const videoDevice = options.videoDevice ?? "1";
+  const audioDevice = options.audioDevice ?? "default";
+  const args = buildFfmpegArgs(outputPath, videoDevice, audioDevice, duration);
+  log(`Recording screen+audio: duration=${duration}s, output=${outputPath}`);
+  await new Promise((resolve4, reject) => {
+    execFileCb2(
+      "ffmpeg",
+      args,
+      { env: SAFE_CHILD_ENV2, timeout: (duration + 30) * 1e3 },
+      (error) => {
+        if (error) {
+          reject(
+            new Error(
+              `Screen recording failed: ${error.message}
+Ensure ffmpeg is installed and Screen Recording + Microphone permissions are granted.`
+            )
+          );
+          return;
+        }
+        resolve4();
+      }
+    );
+  });
+  await validateOutputFile(outputPath);
+  log(`Screen recording complete: ${outputPath}`);
+  return outputPath;
+}
+function start(options) {
+  const outputPath = resolve3(options.outputPath);
+  const videoDevice = options.videoDevice ?? "1";
+  const audioDevice = options.audioDevice ?? "default";
+  const args = buildFfmpegArgs(outputPath, videoDevice, audioDevice);
+  log(`Starting long-form recording: output=${outputPath}`);
+  const child = execFileCb2(
+    "ffmpeg",
+    args,
+    { env: SAFE_CHILD_ENV2 },
+    (error) => {
+      if (error && !error.killed) {
+        log(`Recording process exited with error: ${error.message}`);
+      }
+    }
+  );
+  return child;
+}
+async function stop(process2) {
+  if (process2.exitCode !== null) {
+    log("Recording process already exited");
+    return;
+  }
+  log("Stopping recording (SIGINT \u2192 ffmpeg)...");
+  return new Promise((resolve4, reject) => {
+    const forceKillTimeout = setTimeout(() => {
+      log("Force-killing recording process (10s timeout exceeded)");
+      process2.kill("SIGKILL");
+    }, 1e4);
+    process2.once("exit", (code) => {
+      clearTimeout(forceKillTimeout);
+      log(`Recording process exited with code ${code}`);
+      resolve4();
+    });
+    process2.once("error", (err) => {
+      clearTimeout(forceKillTimeout);
+      reject(new Error(`Error stopping recording: ${err.message}`));
+    });
+    process2.kill("SIGINT");
+  });
+}
+async function validateOutputFile(outputPath) {
+  let fileStats;
+  try {
+    fileStats = await stat2(outputPath);
+  } catch {
+    throw new Error(
+      `Recording file not created at ${outputPath}.
+Check Screen Recording and Microphone permissions in System Settings \u2192 Privacy & Security.`
+    );
+  }
+  if (!fileStats.isFile() || fileStats.size === 0) {
+    throw new Error(
+      "Recording file is empty (0 bytes). Permissions may not be granted.\nCheck System Settings \u2192 Privacy & Security \u2192 Screen Recording and Microphone."
+    );
+  }
+}
+
+// src/cli/CLIPipeline.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { stat as stat3, unlink as unlink2, writeFile as writeFile2, chmod as chmod2 } from "fs/promises";
+import { join as join5, basename as basename3 } from "path";
+import { execFile as execFileCb4 } from "child_process";
+import { tmpdir as tmpdir2 } from "os";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/main/pipeline/TranscriptAnalyzer.ts
+var PAUSE_THRESHOLD_SECONDS = 1.5;
+var PERIODIC_INTERVAL_SECONDS = 15;
+var MAX_PERIODIC_INTERVAL_SECONDS = 20;
+var MAX_KEY_MOMENTS = 20;
+var FRAME_EDGE_MARGIN_SECONDS = 0.35;
+var TranscriptAnalyzer = class {
+  /**
+   * Analyze transcript segments and return key moments where frames
+   * should be extracted from the video recording.
+   *
+   * @param segments - Array of transcript segments with timing info
+   * @param aiHints - Optional AI-informed key-moment hints to merge
+   * @returns Array of key moments sorted by timestamp, capped at 20
+   */
+  analyze(segments, aiHints = []) {
+    if (segments.length === 0) {
+      return [];
+    }
+    const moments = [];
+    const firstSegment = segments[0];
+    const lastSegment = segments[segments.length - 1];
+    const sessionDuration = lastSegment.endTime - firstSegment.startTime;
+    const startOffset = sessionDuration > FRAME_EDGE_MARGIN_SECONDS ? FRAME_EDGE_MARGIN_SECONDS : 0;
+    moments.push({
+      timestamp: firstSegment.startTime + startOffset,
+      reason: "Session start",
+      confidence: 1
+    });
+    for (let i = 1; i < segments.length; i++) {
+      const prev = segments[i - 1];
+      const curr = segments[i];
+      const gap = curr.startTime - prev.endTime;
+      if (gap >= PAUSE_THRESHOLD_SECONDS) {
+        moments.push({
+          timestamp: prev.endTime,
+          reason: "Natural pause in narration",
+          confidence: Math.min(1, gap / 3)
+          // Longer pauses = higher confidence
+        });
+      }
+    }
+    if (lastSegment.endTime > firstSegment.startTime + startOffset) {
+      moments.push({
+        timestamp: lastSegment.endTime,
+        reason: "Session end",
+        confidence: 1
+      });
+    }
+    if (moments.length < 3 && aiHints.length === 0) {
+      if (sessionDuration > PERIODIC_INTERVAL_SECONDS) {
+        const rawCount = Math.floor(sessionDuration / PERIODIC_INTERVAL_SECONDS);
+        const interval = Math.min(
+          sessionDuration / rawCount,
+          MAX_PERIODIC_INTERVAL_SECONDS
+        );
+        for (let t = firstSegment.startTime + interval; t < lastSegment.endTime; t += interval) {
+          moments.push({
+            timestamp: t,
+            reason: "Periodic capture",
+            confidence: 0.5
+          });
+        }
+      }
+    }
+    for (const hint of aiHints) {
+      if (!Number.isFinite(hint.timestamp)) {
+        continue;
+      }
+      moments.push({
+        timestamp: Math.max(0, hint.timestamp),
+        reason: hint.reason?.trim() || "AI-highlighted context",
+        confidence: Math.max(0, Math.min(1, Number.isFinite(hint.confidence) ? hint.confidence : 0.8))
+      });
+    }
+    const deduped = this.deduplicateMoments(moments);
+    deduped.sort((a, b) => a.timestamp - b.timestamp);
+    if (deduped.length > MAX_KEY_MOMENTS) {
+      const first = deduped[0];
+      const last = deduped[deduped.length - 1];
+      const middle = deduped.slice(1, -1).sort((a, b) => {
+        const priorityDelta = this.momentPriority(b) - this.momentPriority(a);
+        if (priorityDelta !== 0) {
+          return priorityDelta;
+        }
+        return b.confidence - a.confidence;
+      }).slice(0, MAX_KEY_MOMENTS - 2);
+      const capped = [first, ...middle, last];
+      capped.sort((a, b) => a.timestamp - b.timestamp);
+      return capped;
+    }
+    return deduped;
+  }
+  /**
+   * Remove moments that are within 1 second of each other,
+   * keeping the one with higher confidence.
+   */
+  deduplicateMoments(moments) {
+    if (moments.length <= 1) {
+      return moments;
+    }
+    const sorted = [...moments].sort((a, b) => a.timestamp - b.timestamp);
+    const result = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+      const prev = result[result.length - 1];
+      const curr = sorted[i];
+      if (curr.timestamp - prev.timestamp < 1) {
+        const currPriority = this.momentPriority(curr);
+        const prevPriority = this.momentPriority(prev);
+        if (currPriority > prevPriority || currPriority === prevPriority && curr.confidence > prev.confidence) {
+          result[result.length - 1] = curr;
+        }
+      } else {
+        result.push(curr);
+      }
+    }
+    return result;
+  }
+  momentPriority(moment) {
+    const reason = (moment.reason || "").toLowerCase();
+    if (reason.includes("session start") || reason.includes("session end")) {
+      return 4;
+    }
+    if (reason.includes("ai-") || reason.includes("ai ")) {
+      return 3;
+    }
+    if (reason.includes("natural pause")) {
+      return 2;
+    }
+    if (reason.includes("periodic")) {
+      return 0;
+    }
+    return 1;
+  }
+};
+var transcriptAnalyzer = new TranscriptAnalyzer();
+
+// src/main/pipeline/FrameExtractor.ts
+import { execFile as execFileCb3 } from "child_process";
+import { promisify } from "util";
+import { existsSync, mkdirSync } from "fs";
+import { stat as statFile } from "fs/promises";
+import { join as join3 } from "path";
+var execFile = promisify(execFileCb3);
+var DEFAULT_MAX_FRAMES = 20;
+var FFMPEG_ACCURATE_FRAME_TIMEOUT_MS = 2e4;
+var FFMPEG_FAST_FRAME_TIMEOUT_MS = 1e4;
+var FFMPEG_CHECK_TIMEOUT_MS = 5e3;
+var FRAME_EDGE_MARGIN_SECONDS2 = 0.35;
+var TIMESTAMP_DEDUPE_WINDOW_SECONDS = 0.15;
+var SAFE_CHILD_ENV3 = {
+  PATH: process.env.PATH,
+  HOME: process.env.HOME || process.env.USERPROFILE,
+  USERPROFILE: process.env.USERPROFILE,
+  LANG: process.env.LANG,
+  TMPDIR: process.env.TMPDIR || process.env.TEMP,
+  TEMP: process.env.TEMP
+};
+var FrameExtractor = class {
+  ffmpegPath = "ffmpeg";
+  ffprobePath = "ffprobe";
+  ffmpegChecked = false;
+  ffmpegAvailable = false;
+  /**
+   * Check if ffmpeg is installed and accessible on the system PATH.
+   * Result is cached after the first successful check.
+   */
+  async checkFfmpeg() {
+    if (this.ffmpegChecked) {
+      return this.ffmpegAvailable;
+    }
+    try {
+      await execFile(this.ffmpegPath, ["-version"], {
+        timeout: FFMPEG_CHECK_TIMEOUT_MS,
+        env: SAFE_CHILD_ENV3
+      });
+      this.ffmpegAvailable = true;
+      this.log("ffmpeg is available");
+    } catch {
+      this.ffmpegAvailable = false;
+      this.log("ffmpeg is not available - frame extraction will be skipped");
+    }
+    this.ffmpegChecked = true;
+    return this.ffmpegAvailable;
+  }
+  /**
+   * Extract frames from a video file at the specified timestamps.
+   *
+   * @param request - Extraction parameters (video path, timestamps, output dir)
+   * @returns Result with extracted frame paths and ffmpeg availability status
+   */
+  async extract(request) {
+    const available = await this.checkFfmpeg();
+    if (!available) {
+      return { frames: [], ffmpegAvailable: false };
+    }
+    const maxFrames = request.maxFrames ?? DEFAULT_MAX_FRAMES;
+    let timestamps = [...request.timestamps].sort((a, b) => a - b);
+    if (timestamps.length > maxFrames) {
+      timestamps = this.selectDistributed(timestamps, maxFrames);
+    }
+    const videoDurationSeconds = await this.getVideoDurationSeconds(request.videoPath);
+    timestamps = this.normalizeTimestamps(timestamps, videoDurationSeconds);
+    if (timestamps.length === 0) {
+      return { frames: [], ffmpegAvailable: true };
+    }
+    const screenshotsDir = join3(request.outputDir, "screenshots");
+    if (!existsSync(screenshotsDir)) {
+      mkdirSync(screenshotsDir, { recursive: true });
+    }
+    const frames = [];
+    for (let i = 0; i < timestamps.length; i++) {
+      const timestamp = timestamps[i];
+      const frameNumber = String(i + 1).padStart(3, "0");
+      const outputPath = join3(screenshotsDir, `frame-${frameNumber}.png`);
+      try {
+        await this.extractSingleFrame(request.videoPath, timestamp, outputPath);
+        const stats = await statFile(outputPath).catch(() => null);
+        if (!stats || stats.size <= 0) {
+          throw new Error(`ffmpeg did not produce a frame file at timestamp ${timestamp.toFixed(1)}s. The video may be shorter than expected or the codec may not support seeking.`);
+        }
+        frames.push({
+          path: outputPath,
+          timestamp,
+          success: true
+        });
+        this.log(`Extracted frame ${frameNumber} at ${timestamp.toFixed(2)}s`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.log(`Failed to extract frame at ${timestamp.toFixed(2)}s: ${message}`);
+        frames.push({
+          path: outputPath,
+          timestamp,
+          success: false
+        });
+      }
+    }
+    return { frames, ffmpegAvailable: true };
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Extract a single frame from the video at the given timestamp.
+   */
+  async extractSingleFrame(videoPath, timestamp, outputPath) {
+    try {
+      await this.extractSingleFrameAccurate(videoPath, timestamp, outputPath);
+      return;
+    } catch (accurateError) {
+      this.log(
+        `Accurate extraction failed at ${timestamp.toFixed(2)}s, retrying fast seek: ${accurateError instanceof Error ? accurateError.message : String(accurateError)}`
+      );
+    }
+    await this.extractSingleFrameFast(videoPath, timestamp, outputPath);
+  }
+  async extractSingleFrameAccurate(videoPath, timestamp, outputPath) {
+    const args = [
+      "-i",
+      videoPath,
+      "-ss",
+      String(timestamp),
+      "-frames:v",
+      "1",
+      "-vf",
+      "format=rgb24",
+      "-q:v",
+      "2",
+      "-y",
+      outputPath
+    ];
+    await execFile(this.ffmpegPath, args, {
+      timeout: FFMPEG_ACCURATE_FRAME_TIMEOUT_MS,
+      env: SAFE_CHILD_ENV3
+    });
+  }
+  async extractSingleFrameFast(videoPath, timestamp, outputPath) {
+    const args = [
+      "-ss",
+      String(timestamp),
+      "-i",
+      videoPath,
+      "-frames:v",
+      "1",
+      "-vf",
+      "format=rgb24",
+      "-q:v",
+      "2",
+      "-y",
+      // overwrite output file if it exists
+      outputPath
+    ];
+    await execFile(this.ffmpegPath, args, {
+      timeout: FFMPEG_FAST_FRAME_TIMEOUT_MS,
+      env: SAFE_CHILD_ENV3
+    });
+  }
+  /**
+   * Select evenly distributed timestamps from a sorted array.
+   * Always includes the first and last timestamp.
+   */
+  selectDistributed(sorted, count) {
+    if (sorted.length <= count) {
+      return sorted;
+    }
+    if (count <= 0) {
+      return [];
+    }
+    if (count === 1) {
+      return [sorted[0]];
+    }
+    const result = [sorted[0]];
+    const step = (sorted.length - 1) / (count - 1);
+    for (let i = 1; i < count - 1; i++) {
+      const index = Math.round(i * step);
+      result.push(sorted[index]);
+    }
+    result.push(sorted[sorted.length - 1]);
+    return result;
+  }
+  async getVideoDurationSeconds(videoPath) {
+    try {
+      const { stdout } = await execFile(
+        this.ffprobePath,
+        [
+          "-v",
+          "error",
+          "-show_entries",
+          "format=duration",
+          "-of",
+          "default=noprint_wrappers=1:nokey=1",
+          videoPath
+        ],
+        { timeout: FFMPEG_CHECK_TIMEOUT_MS, env: SAFE_CHILD_ENV3 }
+      );
+      const parsed = Number.parseFloat(String(stdout).trim());
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+      }
+      return null;
+    } catch (error) {
+      this.log(`ffprobe duration probe failed: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  normalizeTimestamps(timestamps, durationSeconds) {
+    const cleaned = timestamps.map((timestamp) => Number.isFinite(timestamp) ? Math.max(0, timestamp) : 0).sort((a, b) => a - b);
+    if (cleaned.length === 0) {
+      return [];
+    }
+    let clamped = cleaned;
+    if (durationSeconds && durationSeconds > 0) {
+      const minTs = Math.min(FRAME_EDGE_MARGIN_SECONDS2, Math.max(0, durationSeconds - 0.05));
+      const maxTs = Math.max(minTs, durationSeconds - FRAME_EDGE_MARGIN_SECONDS2);
+      clamped = cleaned.map((timestamp) => Math.max(minTs, Math.min(timestamp, maxTs)));
+    }
+    const deduped = [];
+    for (const timestamp of clamped) {
+      const previous = deduped[deduped.length - 1];
+      if (previous === void 0 || Math.abs(timestamp - previous) >= TIMESTAMP_DEDUPE_WINDOW_SECONDS) {
+        deduped.push(timestamp);
+      }
+    }
+    return deduped;
+  }
+  /**
+   * Log helper with consistent prefix.
+   */
+  log(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    console.log(`[FrameExtractor ${timestamp}] ${message}`);
+  }
+};
+var frameExtractor = new FrameExtractor();
+
+// src/main/output/MarkdownGenerator.ts
+import * as path2 from "path";
+var REPORT_SUPPORT_LINE = "*If this report saved you time, support development: [Ko-fi](https://ko-fi.com/eddiesanjuan)*";
+var MarkdownGeneratorImpl = class {
+  /**
+   * Generate a full markdown document with all feedback items and metadata.
+   * Follows llms.txt-inspired format for AI readability.
+   */
+  generateFullDocument(session, options) {
+    const { projectName, screenshotDir } = options;
+    const items = session.feedbackItems;
+    const duration = session.endTime ? this.formatDuration(session.endTime - session.startTime) : "In Progress";
+    const timestamp = this.formatTimestamp(session.endTime || Date.now());
+    const filename = this.generateFilename(projectName, session.startTime);
+    if (items.length === 0) {
+      const content2 = `# ${projectName} Feedback Report
+> Generated by markupr on ${timestamp}
+> Duration: ${duration}
+
+_No feedback items were captured during this session._
+
+---
+*Generated by [markupr](https://markupr.com)*
+${REPORT_SUPPORT_LINE}
+`;
+      return {
+        content: content2,
+        filename,
+        metadata: {
+          itemCount: 0,
+          screenshotCount: 0,
+          duration: session.endTime ? session.endTime - session.startTime : 0,
+          types: {}
+        }
+      };
+    }
+    const typeCounts = this.countTypes(items);
+    const severityCounts = this.countSeverities(items);
+    const screenshotCount = this.countScreenshots(items);
+    const topThemes = this.extractTopThemes(items);
+    const highImpactCount = (severityCounts.Critical || 0) + (severityCounts.High || 0);
+    const platform = session.metadata?.os || process?.platform || "Unknown";
+    let content = `# ${projectName} Feedback Report
+> Generated by markupr on ${timestamp}
+> Duration: ${duration} | Items: ${items.length} | Screenshots: ${screenshotCount}
+
+## Session Overview
+- **Session ID:** \`${session.id}\`
+- **Source:** ${session.metadata?.sourceName || "Unknown"} (${session.metadata?.sourceType || "screen"})
+- **Platform:** ${platform}
+- **Segments:** ${items.length}
+- **High-impact items:** ${highImpactCount}
+
+---
+
+## Executive Summary
+
+- ${items.length} total feedback items were captured.
+- ${highImpactCount} items are categorized as **Critical** or **High** priority.
+- ${screenshotCount} screenshots were aligned to spoken context.
+`;
+    if (topThemes.length > 0) {
+      content += `- Top themes: ${topThemes.join(", ")}.
+`;
+    }
+    content += `
+---
+
+## Actionable Feedback
+
+`;
+    items.forEach((item, index) => {
+      const id = this.generateFeedbackItemId(index);
+      const title = item.title || this.generateTitle(item.transcription);
+      const itemTimestamp = this.formatItemTimestamp(item.timestamp - session.startTime);
+      const category = item.category || "General";
+      const severity = item.severity || this.defaultSeverityForCategory(category);
+      const signals = item.keywords?.slice(0, 5) || [];
+      const suggestedAction = this.suggestAction(category, severity, item.transcription);
+      content += `### ${id}: ${title}
+- **Severity:** ${severity}
+- **Type:** ${category}
+- **Timestamp:** ${itemTimestamp}
+`;
+      if (signals.length > 0) {
+        content += `- **Signals:** ${signals.join(", ")}
+`;
+      }
+      content += `
+#### What Happened
+
+> ${this.wrapTranscription(item.transcription)}
+
+`;
+      if (item.screenshots.length > 0) {
+        content += `#### Evidence
+`;
+        item.screenshots.forEach((ss, ssIndex) => {
+          const screenshotFilename = this.generateScreenshotFilename(index, ssIndex, item.screenshots.length);
+          content += `![${id}${item.screenshots.length > 1 ? `-${ssIndex + 1}` : ""}](${screenshotDir}/${screenshotFilename})
+
+`;
+        });
+      } else {
+        content += `#### Evidence
+_No screenshot captured for this item._
+
+`;
+      }
+      content += `#### Suggested Next Step
+- ${suggestedAction}
+
+`;
+      content += `---
+
+`;
+    });
+    content += `## Summary
+
+| Type | Count |
+|------|-------|
+`;
+    Object.entries(typeCounts).forEach(([type, count]) => {
+      content += `| ${type} | ${count} |
+`;
+    });
+    content += `| **Total** | **${items.length}** |
+`;
+    content += `
+| Severity | Count |
+|----------|-------|
+`;
+    Object.entries(severityCounts).forEach(([severity, count]) => {
+      content += `| ${severity} | ${count} |
+`;
+    });
+    content += `| **Total** | **${items.length}** |
+`;
+    content += `
+---
+*Generated by [markupr](https://markupr.com)*
+${REPORT_SUPPORT_LINE}
+`;
+    return {
+      content,
+      filename,
+      metadata: {
+        itemCount: items.length,
+        screenshotCount,
+        duration: session.endTime ? session.endTime - session.startTime : 0,
+        types: typeCounts
+      }
+    };
+  }
+  /**
+   * Generate markdown from a PostProcessResult (post-recording pipeline output).
+   *
+   * Produces a clean, AI-readable document with:
+   * - Session header with human-readable timestamp
+   * - Each transcript segment as a heading with [M:SS] timestamp
+   * - Blockquoted transcript text
+   * - Associated frame images referenced as relative paths
+   *
+   * @param result - The combined transcript + frame output from PostProcessor
+   * @param sessionDir - Absolute path to the session directory (used to compute relative frame paths)
+   * @returns The generated markdown string
+   */
+  generateFromPostProcess(result, sessionDir) {
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = this.formatDateDeterministic(/* @__PURE__ */ new Date());
+    const sessionDuration = transcriptSegments.length > 0 ? this.formatDuration(
+      (transcriptSegments[transcriptSegments.length - 1].endTime - transcriptSegments[0].startTime) * 1e3
+    ) : "0:00";
+    let md = `# markupr Session \u2014 ${sessionTimestamp}
+`;
+    md += `> Segments: ${transcriptSegments.length} | Frames: ${extractedFrames.length} | Duration: ${sessionDuration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No speech was detected during this recording._
+`;
+      return md;
+    }
+    md += `## Transcript
+
+`;
+    const segmentFrameMap = this.mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = this.formatPostProcessTimestamp(segment.startTime);
+      const title = this.generateSegmentTitle(segment.text);
+      md += `### [${formattedTime}] ${title}
+`;
+      md += `> ${this.wrapTranscription(segment.text)}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const frameTimestamp = this.formatPostProcessTimestamp(frame.timestamp);
+          const relativePath = this.computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Frame at ${frameTimestamp}](${relativePath})
+
+`;
+        }
+      }
+    }
+    md += `---
+*Generated by [markupr](https://markupr.com)*
+${REPORT_SUPPORT_LINE}
+`;
+    return md;
+  }
+  /**
+   * Map extracted frames to their closest transcript segments.
+   * Returns a Map from segment index to an array of frames.
+   */
+  mapFramesToSegments(segments, frames) {
+    const map = /* @__PURE__ */ new Map();
+    for (const frame of frames) {
+      let bestIndex = 0;
+      let bestDistance = Infinity;
+      for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (frame.timestamp >= seg.startTime && frame.timestamp <= seg.endTime) {
+          bestIndex = i;
+          bestDistance = 0;
+          break;
+        }
+        const distance = Math.abs(frame.timestamp - seg.startTime);
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          bestIndex = i;
+        }
+      }
+      const existing = map.get(bestIndex) || [];
+      existing.push(frame);
+      map.set(bestIndex, existing);
+    }
+    for (const [, frameList] of map) {
+      frameList.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    return map;
+  }
+  /**
+   * Compute a relative path for a frame image from the session directory.
+   * If the frame path is already relative, return it as-is.
+   * If absolute, compute the relative path from sessionDir.
+   */
+  computeRelativeFramePath(framePath, sessionDir) {
+    if (!path2.isAbsolute(framePath)) {
+      return framePath;
+    }
+    return path2.relative(sessionDir, framePath);
+  }
+  /**
+   * Format a timestamp in seconds to M:SS format for post-process output.
+   * Examples: 0 -> "0:00", 15.3 -> "0:15", 125 -> "2:05"
+   */
+  formatPostProcessTimestamp(seconds) {
+    const totalSeconds = Math.max(0, Math.floor(seconds));
+    const mins = Math.floor(totalSeconds / 60);
+    const secs = totalSeconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  }
+  /**
+   * Generate a short title from transcript text (first sentence, max 60 chars).
+   */
+  generateSegmentTitle(text) {
+    const firstSentence = text.split(/[.!?]/)[0].trim();
+    if (firstSentence.length <= 60) return firstSentence;
+    return firstSentence.slice(0, 57) + "...";
+  }
+  /**
+   * Generate a clipboard-friendly summary (<1500 chars).
+   * Includes priority items and a reference to the full report.
+   *
+   * @param session - Session data
+   * @param projectName - Optional project name for the header
+   * @param reportPath - Optional absolute or relative path to the full report file.
+   *                     When provided, the summary links to this path instead of the
+   *                     generic ./feedback-report.md placeholder.
+   */
+  generateClipboardSummary(session, projectName, reportPath) {
+    const name = projectName || session.metadata?.sourceName || "Project";
+    const items = session.feedbackItems;
+    let summary = `# Feedback: ${name} - ${items.length} items
+
+`;
+    const maxPriorityItems = 3;
+    summary += `## Priority Items
+`;
+    items.slice(0, maxPriorityItems).forEach((item, index) => {
+      const id = this.generateFeedbackItemId(index);
+      const title = this.generateTitle(item.transcription);
+      const oneLineSummary = this.truncateText(item.transcription, 60);
+      summary += `- **${id}:** ${title} - ${oneLineSummary}
+`;
+    });
+    if (items.length > maxPriorityItems) {
+      const remainingIds = items.slice(maxPriorityItems).map((_, i) => this.generateFeedbackItemId(i + maxPriorityItems)).join(", ");
+      summary += `
+## Other
+- ${remainingIds} (see full report)
+`;
+    }
+    summary += `
+**Full report:** ${reportPath || "./feedback-report.md"}`;
+    if (summary.length > 1500) {
+      summary = summary.slice(0, 1497) + "...";
+    }
+    return summary;
+  }
+  /**
+   * Generate a feedback item ID (FB-001, FB-002, etc.)
+   */
+  generateFeedbackItemId(index) {
+    return `FB-${(index + 1).toString().padStart(3, "0")}`;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  /**
+   * Generate a title from the transcription (first sentence or 50 chars)
+   */
+  generateTitle(transcription) {
+    const firstSentence = transcription.split(/[.!?]/)[0].trim();
+    if (firstSentence.length <= 50) return firstSentence;
+    return firstSentence.slice(0, 47) + "...";
+  }
+  /**
+   * Truncate text to specified length
+   */
+  truncateText(text, maxLength) {
+    if (text.length <= maxLength) return text;
+    return text.slice(0, maxLength - 3) + "...";
+  }
+  /**
+   * Wrap transcription for markdown blockquote (handle multi-line).
+   * Splits on sentence-ending punctuation followed by whitespace so that
+   * all multi-sentence inputs (including 2-sentence ones) get proper
+   * blockquote continuation lines.
+   */
+  wrapTranscription(transcription) {
+    if (!transcription.includes(".") && !transcription.includes("!") && !transcription.includes("?")) {
+      return transcription;
+    }
+    const sentences = transcription.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+    if (sentences.length <= 1) return transcription;
+    return sentences.join("\n> ");
+  }
+  /**
+   * Format duration from milliseconds to M:SS
+   */
+  formatDuration(ms) {
+    const totalSeconds = Math.floor(ms / 1e3);
+    const mins = Math.floor(totalSeconds / 60);
+    const secs = totalSeconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  }
+  /**
+   * Format timestamp to a deterministic human-readable string.
+   * Uses explicit formatting instead of toLocaleString to produce
+   * consistent output across platforms and Node.js versions.
+   */
+  formatTimestamp(ms) {
+    return this.formatDateDeterministic(new Date(ms));
+  }
+  /**
+   * Produce a deterministic date string: "Feb 14, 2026 at 10:30 AM".
+   * Avoids toLocaleString which can vary across OS versions.
+   */
+  formatDateDeterministic(date) {
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    const month = months[date.getMonth()];
+    const day = date.getDate();
+    const year = date.getFullYear();
+    const rawHours = date.getHours();
+    const ampm = rawHours >= 12 ? "PM" : "AM";
+    const hours = rawHours % 12 || 12;
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    return `${month} ${day}, ${year} at ${hours}:${minutes} ${ampm}`;
+  }
+  /**
+   * Format item timestamp as MM:SS from session start
+   */
+  formatItemTimestamp(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+    const mins = Math.floor(totalSeconds / 60);
+    const secs = totalSeconds % 60;
+    return `${mins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  }
+  /**
+   * Generate filename following pattern: {project}-feedback-{YYYYMMDD-HHmmss}.md
+   */
+  generateFilename(projectName, startTime) {
+    const date = new Date(startTime);
+    const year = date.getFullYear();
+    const month = (date.getMonth() + 1).toString().padStart(2, "0");
+    const day = date.getDate().toString().padStart(2, "0");
+    const hours = date.getHours().toString().padStart(2, "0");
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    const seconds = date.getSeconds().toString().padStart(2, "0");
+    const dateStr = `${year}${month}${day}`;
+    const timeStr = `${hours}${minutes}${seconds}`;
+    const safeName = projectName.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-");
+    return `${safeName}-feedback-${dateStr}-${timeStr}.md`;
+  }
+  /**
+   * Generate screenshot filename for a feedback item.
+   * Uses the item's position index to produce `fb-{NNN}.png`, matching the
+   * naming convention in FileManager.saveSession.
+   */
+  generateScreenshotFilename(itemIndex, screenshotIndex, total) {
+    const num = (itemIndex + 1).toString().padStart(3, "0");
+    const suffix = total > 1 ? `-${screenshotIndex + 1}` : "";
+    return `fb-${num}${suffix}.png`;
+  }
+  /**
+   * Provide a severity fallback when upstream analysis is unavailable.
+   */
+  defaultSeverityForCategory(category) {
+    switch (category) {
+      case "Bug":
+        return "High";
+      case "Performance":
+        return "High";
+      case "UX Issue":
+        return "Medium";
+      case "Suggestion":
+        return "Low";
+      case "Question":
+        return "Low";
+      default:
+        return "Medium";
+    }
+  }
+  countSeverities(items) {
+    return items.reduce((acc, item) => {
+      const severity = item.severity || this.defaultSeverityForCategory(item.category || "General");
+      acc[severity] = (acc[severity] || 0) + 1;
+      return acc;
+    }, {});
+  }
+  extractTopThemes(items) {
+    const counts = /* @__PURE__ */ new Map();
+    items.forEach((item) => {
+      (item.keywords || []).forEach((keyword) => {
+        const normalized = keyword.toLowerCase();
+        counts.set(normalized, (counts.get(normalized) || 0) + 1);
+      });
+    });
+    return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([keyword]) => keyword);
+  }
+  suggestAction(category, severity, transcription) {
+    const excerpt = this.truncateText(transcription, 120);
+    switch (category) {
+      case "Bug":
+        return `Reproduce and patch this defect, then add a regression test that validates: "${excerpt}".`;
+      case "Performance":
+        return `Profile this flow, target the slow step first, and validate before/after metrics for: "${excerpt}".`;
+      case "UX Issue":
+        return `Revise the UI interaction and run a quick usability check focused on: "${excerpt}".`;
+      case "Suggestion":
+        return severity === "High" || severity === "Critical" ? `Treat this suggestion as near-term roadmap work and define implementation scope for: "${excerpt}".` : `Track this as an enhancement request and prioritize against current sprint goals: "${excerpt}".`;
+      case "Question":
+        return `Answer this explicitly in product/docs so future reviews don't block on: "${excerpt}".`;
+      default:
+        return `Investigate this item and convert it into a concrete engineering task: "${excerpt}".`;
+    }
+  }
+  /**
+   * Count feedback items by type/category
+   */
+  countTypes(items) {
+    return items.reduce((acc, item) => {
+      const type = item.category || "General";
+      acc[type] = (acc[type] || 0) + 1;
+      return acc;
+    }, {});
+  }
+  /**
+   * Count total screenshots across all items
+   */
+  countScreenshots(items) {
+    return items.reduce((sum, item) => sum + item.screenshots.length, 0);
+  }
+};
+var markdownGenerator = new MarkdownGeneratorImpl();
+
+// src/main/transcription/WhisperService.ts
+import { EventEmitter } from "events";
+import { basename as basename2, join as join4 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, unlink, chmod } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+import * as os2 from "os";
+var execFileAsync = promisify2(execFile2);
+var DEFAULT_CONFIG = {
+  modelPath: "",
+  // Set dynamically
+  language: "en",
+  threads: Math.max(1, Math.floor(os2.cpus().length / 2)),
+  // Half CPU cores
+  translateToEnglish: false
+};
+var CHUNK_DURATION_MS = 3e3;
+var MAX_BUFFER_DURATION_MS = 3e4;
+var MAX_BUFFER_SIZE_BYTES = 500 * 1024;
+var SAMPLE_RATE = 16e3;
+var FILE_CHUNK_DURATION_SEC = 30;
+var FILE_CHUNK_SAMPLES = FILE_CHUNK_DURATION_SEC * SAMPLE_RATE;
+var MODEL_MEMORY_REQUIREMENTS_BYTES = {
+  "ggml-tiny.bin": 450 * 1024 * 1024,
+  "ggml-base.bin": 800 * 1024 * 1024,
+  "ggml-small.bin": 1400 * 1024 * 1024,
+  "ggml-medium.bin": 2800 * 1024 * 1024,
+  "ggml-large-v3.bin": 5200 * 1024 * 1024
+};
+var WhisperService = class extends EventEmitter {
+  config;
+  isInitialized = false;
+  isProcessing = false;
+  whisperModule = null;
+  // Audio buffering for batch processing
+  audioBuffer = [];
+  bufferStartTime = 0;
+  totalBufferDuration = 0;
+  totalBufferBytes = 0;
+  // Processing state
+  processingInterval = null;
+  // Callbacks
+  transcriptCallbacks = [];
+  errorCallbacks = [];
+  constructor(config) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    if (!this.config.modelPath) {
+      this.config.modelPath = this.getDefaultModelPath();
+    }
+  }
+  // ============================================================================
+  // Public API
+  // ============================================================================
+  /**
+   * Check if Whisper model is available
+   */
+  isModelAvailable() {
+    return existsSync2(this.config.modelPath);
+  }
+  /**
+   * Get the path where models should be stored
+   */
+  getModelsDirectory() {
+    try {
+      const { app } = __require("electron");
+      return join4(app.getPath("userData"), "whisper-models");
+    } catch {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || os2.homedir();
+      return join4(homeDir, ".markupr", "whisper-models");
+    }
+  }
+  /**
+   * Get the default model path (whisper-medium)
+   */
+  getDefaultModelPath() {
+    return join4(this.getModelsDirectory(), "ggml-medium.bin");
+  }
+  /**
+   * Set the model path
+   */
+  setModelPath(modelPath) {
+    this.config.modelPath = modelPath;
+    this.isInitialized = false;
+  }
+  /**
+   * Check if system has enough memory for Whisper
+   * Requirement is model-aware (tiny/base/small/medium/large).
+   */
+  hasEnoughMemory() {
+    const freeMemory = os2.freemem();
+    const requiredMemory = this.getRequiredMemoryBytes();
+    return freeMemory >= requiredMemory;
+  }
+  /**
+   * Get current memory info
+   */
+  getMemoryInfo() {
+    const freeMemory = os2.freemem();
+    const requiredMemory = this.getRequiredMemoryBytes();
+    return {
+      freeMemoryMB: Math.round(freeMemory / 1024 / 1024),
+      requiredMemoryMB: Math.round(requiredMemory / 1024 / 1024),
+      sufficient: freeMemory >= requiredMemory
+    };
+  }
+  /**
+   * Initialize the Whisper model
+   * Call this once before starting transcription
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      return;
+    }
+    if (!this.isModelAvailable()) {
+      throw new Error(`Whisper model not found at ${this.config.modelPath}. Please download the model first.`);
+    }
+    if (!this.hasEnoughMemory()) {
+      const memInfo = this.getMemoryInfo();
+      throw new Error(
+        `Insufficient memory for Whisper. Need ~${memInfo.requiredMemoryMB}MB free, only ${memInfo.freeMemoryMB}MB available.`
+      );
+    }
+    this.log("Initializing Whisper model...");
+    try {
+      this.whisperModule = await import("whisper-node");
+      if (!this.whisperModule || typeof this.whisperModule.whisper !== "function") {
+        throw new Error("whisper-node module loaded but whisper function not found");
+      }
+      this.log("Pre-loading model with test transcription...");
+      const testBuffer = new Float32Array(1600);
+      await this.whisperModule.whisper(testBuffer, {
+        modelPath: this.config.modelPath,
+        language: this.config.language,
+        threads: this.config.threads
+      });
+      this.isInitialized = true;
+      this.log("Whisper model initialized successfully");
+    } catch (error) {
+      const initError = new Error(`Failed to initialize Whisper: ${error.message}`);
+      this.errorCallbacks.forEach((cb) => cb(initError));
+      throw initError;
+    }
+  }
+  /**
+   * Check if service is initialized and ready
+   */
+  isReady() {
+    return this.isInitialized && this.whisperModule !== null;
+  }
+  /**
+   * Start accepting audio for transcription
+   */
+  async start() {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    this.audioBuffer = [];
+    this.bufferStartTime = Date.now();
+    this.totalBufferDuration = 0;
+    this.totalBufferBytes = 0;
+    this.processingInterval = setInterval(() => {
+      this.processBufferedAudio();
+    }, CHUNK_DURATION_MS);
+    this.log("Whisper transcription started");
+  }
+  /**
+   * Stop transcription and process remaining audio
+   */
+  async stop() {
+    if (this.processingInterval) {
+      clearInterval(this.processingInterval);
+      this.processingInterval = null;
+    }
+    await this.processBufferedAudio(true);
+    this.audioBuffer = [];
+    this.totalBufferDuration = 0;
+    this.totalBufferBytes = 0;
+    this.log("Whisper transcription stopped");
+  }
+  /**
+   * Add audio data to the buffer
+   * @param samples Float32Array of audio samples at 16kHz mono
+   * @param durationMs Duration of this chunk in milliseconds
+   */
+  addAudio(samples, durationMs) {
+    const chunkBytes = samples.byteLength;
+    if (this.totalBufferBytes + chunkBytes > MAX_BUFFER_SIZE_BYTES) {
+      this.log("Audio buffer full, force-processing before adding new audio");
+      this.processBufferedAudio(true);
+    }
+    this.audioBuffer.push(samples);
+    this.totalBufferDuration += durationMs;
+    this.totalBufferBytes += chunkBytes;
+    if (this.totalBufferDuration >= MAX_BUFFER_DURATION_MS) {
+      this.processBufferedAudio(true);
+    }
+  }
+  /**
+   * Register callback for transcript results
+   */
+  onTranscript(callback) {
+    this.transcriptCallbacks.push(callback);
+    return () => {
+      this.transcriptCallbacks = this.transcriptCallbacks.filter((cb) => cb !== callback);
+    };
+  }
+  /**
+   * Register callback for errors
+   */
+  onError(callback) {
+    this.errorCallbacks.push(callback);
+    return () => {
+      this.errorCallbacks = this.errorCallbacks.filter((cb) => cb !== callback);
+    };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Transcribe a complete Float32 buffer in one pass.
+   * Useful for post-session retry workflows when live streaming failed.
+   */
+  async transcribeSamples(samples, startTimeSec) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    if (!this.whisperModule) {
+      throw new Error("Whisper module not loaded");
+    }
+    const CHUNK_TIMEOUT_MS = 6e4;
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error("Whisper transcription timed out after 60s")),
+        CHUNK_TIMEOUT_MS
+      );
+    });
+    let result;
+    try {
+      result = await Promise.race([
+        this.whisperModule.whisper(samples, {
+          modelPath: this.config.modelPath,
+          language: this.config.language,
+          threads: this.config.threads,
+          translate: this.config.translateToEnglish
+        }),
+        timeoutPromise
+      ]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+    if (!result || result.length === 0) {
+      return [];
+    }
+    return result.map((segment) => ({
+      text: segment.text.trim(),
+      startTime: startTimeSec + segment.start,
+      endTime: startTimeSec + segment.end,
+      confidence: 0.9
+    })).filter((segment) => segment.text.length > 0);
+  }
+  /**
+   * Transcribe an audio file from disk.
+   * Loads the file, converts to Float32Array at 16kHz mono, and transcribes.
+   * For large files, processes in chunks to manage memory.
+   *
+   * @param audioPath - Path to the audio file (webm, wav, ogg, m4a)
+   * @param onProgress - Optional progress callback (0-100)
+   * @returns Array of transcript results with timestamps
+   */
+  async transcribeFile(audioPath, onProgress) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    if (!existsSync2(audioPath)) {
+      throw new Error(`Audio file not found: ${audioPath}`);
+    }
+    this.log(`Transcribing file: ${audioPath}`);
+    onProgress?.(0);
+    const samples = await this.loadAudioAsSamples(audioPath);
+    if (samples.length === 0) {
+      this.log("Audio file produced no samples");
+      onProgress?.(100);
+      return [];
+    }
+    const totalChunks = Math.ceil(samples.length / FILE_CHUNK_SAMPLES);
+    const results = [];
+    this.log(`Processing ${totalChunks} chunk(s) (${(samples.length / SAMPLE_RATE).toFixed(1)}s total)`);
+    for (let i = 0; i < totalChunks; i++) {
+      const chunkStart = i * FILE_CHUNK_SAMPLES;
+      const chunkEnd = Math.min(chunkStart + FILE_CHUNK_SAMPLES, samples.length);
+      const chunk = samples.subarray(chunkStart, chunkEnd);
+      const startTimeSec = chunkStart / SAMPLE_RATE;
+      const chunkResults = await this.transcribeSamples(chunk, startTimeSec);
+      results.push(...chunkResults);
+      const percent = Math.round((i + 1) / totalChunks * 100);
+      onProgress?.(percent);
+      if (i < totalChunks - 1) {
+        await new Promise((resolve4) => setTimeout(resolve4, 0));
+      }
+    }
+    this.log(`Transcription complete: ${results.length} segment(s)`);
+    return results;
+  }
+  /**
+   * Check if ffmpeg is available on the system
+   */
+  async isFfmpegAvailable() {
+    try {
+      await execFileAsync("ffmpeg", ["-version"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Load an audio file and return Float32Array samples at 16kHz mono.
+   * WAV files are parsed directly; other formats are converted via ffmpeg.
+   */
+  async loadAudioAsSamples(audioPath) {
+    const ext = audioPath.toLowerCase().split(".").pop() ?? "";
+    if (ext === "wav") {
+      return this.parseWavFile(audioPath);
+    }
+    return this.convertWithFfmpeg(audioPath);
+  }
+  /**
+   * Parse a WAV file and extract PCM data as Float32Array at 16kHz mono.
+   * Handles PCM float32 and PCM int16 formats.
+   */
+  async parseWavFile(wavPath) {
+    const buffer = await readFile2(wavPath);
+    const riff = buffer.toString("ascii", 0, 4);
+    const wave = buffer.toString("ascii", 8, 12);
+    if (riff !== "RIFF" || wave !== "WAVE") {
+      throw new Error(`Invalid WAV file: missing RIFF/WAVE header in ${wavPath}`);
+    }
+    let offset = 12;
+    let audioFormat = 0;
+    let numChannels = 0;
+    let sampleRate = 0;
+    let bitsPerSample = 0;
+    let fmtFound = false;
+    while (offset < buffer.length - 8) {
+      const chunkId = buffer.toString("ascii", offset, offset + 4);
+      const chunkSize = buffer.readUInt32LE(offset + 4);
+      if (chunkId === "fmt ") {
+        audioFormat = buffer.readUInt16LE(offset + 8);
+        numChannels = buffer.readUInt16LE(offset + 10);
+        sampleRate = buffer.readUInt32LE(offset + 12);
+        bitsPerSample = buffer.readUInt16LE(offset + 22);
+        fmtFound = true;
+      }
+      if (chunkId === "data") {
+        if (!fmtFound) {
+          throw new Error("WAV file has data chunk before fmt chunk");
+        }
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + chunkSize;
+        const dataSlice = buffer.subarray(dataStart, Math.min(dataEnd, buffer.length));
+        return this.extractWavSamples(dataSlice, audioFormat, numChannels, sampleRate, bitsPerSample);
+      }
+      offset += 8 + chunkSize;
+      if (chunkSize % 2 !== 0) {
+        offset += 1;
+      }
+    }
+    throw new Error(`Invalid WAV file: no data chunk found in ${wavPath}`);
+  }
+  /**
+   * Extract samples from WAV data chunk, converting to Float32Array at 16kHz mono.
+   */
+  extractWavSamples(data, audioFormat, numChannels, sampleRate, bitsPerSample) {
+    let monoFloat32;
+    if (audioFormat === 3 && bitsPerSample === 32) {
+      const totalSamples = Math.floor(data.length / 4);
+      const allSamples = new Float32Array(totalSamples);
+      for (let i = 0; i < totalSamples; i++) {
+        allSamples[i] = data.readFloatLE(i * 4);
+      }
+      monoFloat32 = this.mixToMono(allSamples, numChannels);
+    } else if (audioFormat === 1 && bitsPerSample === 16) {
+      const totalSamples = Math.floor(data.length / 2);
+      const allSamples = new Float32Array(totalSamples);
+      for (let i = 0; i < totalSamples; i++) {
+        allSamples[i] = data.readInt16LE(i * 2) / 32768;
+      }
+      monoFloat32 = this.mixToMono(allSamples, numChannels);
+    } else {
+      throw new Error(
+        `Unsupported WAV format: audioFormat=${audioFormat}, bitsPerSample=${bitsPerSample}. Expected PCM float32 (format=3, bits=32) or PCM int16 (format=1, bits=16).`
+      );
+    }
+    if (sampleRate !== SAMPLE_RATE) {
+      return this.resample(monoFloat32, sampleRate, SAMPLE_RATE);
+    }
+    return monoFloat32;
+  }
+  /**
+   * Mix multi-channel audio down to mono by averaging channels.
+   */
+  mixToMono(samples, numChannels) {
+    if (numChannels === 1) {
+      return samples;
+    }
+    const monoLength = Math.floor(samples.length / numChannels);
+    const mono = new Float32Array(monoLength);
+    for (let i = 0; i < monoLength; i++) {
+      let sum = 0;
+      for (let ch = 0; ch < numChannels; ch++) {
+        sum += samples[i * numChannels + ch];
+      }
+      mono[i] = sum / numChannels;
+    }
+    return mono;
+  }
+  /**
+   * Simple linear resampling from one sample rate to another.
+   */
+  resample(samples, fromRate, toRate) {
+    if (fromRate === toRate) {
+      return samples;
+    }
+    const ratio = fromRate / toRate;
+    const outputLength = Math.floor(samples.length / ratio);
+    const output = new Float32Array(outputLength);
+    for (let i = 0; i < outputLength; i++) {
+      const srcIndex = i * ratio;
+      const srcIndexFloor = Math.floor(srcIndex);
+      const srcIndexCeil = Math.min(srcIndexFloor + 1, samples.length - 1);
+      const frac = srcIndex - srcIndexFloor;
+      output[i] = samples[srcIndexFloor] * (1 - frac) + samples[srcIndexCeil] * frac;
+    }
+    return output;
+  }
+  /**
+   * Convert a non-WAV audio file to 16kHz mono Float32 WAV using ffmpeg,
+   * then parse the resulting WAV.
+   */
+  async convertWithFfmpeg(audioPath) {
+    const ffmpegAvailable = await this.isFfmpegAvailable();
+    if (!ffmpegAvailable) {
+      const installHint = process.platform === "darwin" ? "brew install ffmpeg" : process.platform === "win32" ? "winget install ffmpeg or download from https://ffmpeg.org" : "apt install ffmpeg (Debian/Ubuntu) or dnf install ffmpeg (Fedora)";
+      throw new Error(
+        `ffmpeg is not available on this system. ffmpeg is required to transcribe non-WAV audio files (webm, ogg, m4a). Install ffmpeg via: ${installHint}.`
+      );
+    }
+    const tempFileName = `markupr-transcode-${randomUUID()}.wav`;
+    const tempPath = join4(tmpdir(), tempFileName);
+    try {
+      this.log(`Converting ${audioPath} to WAV via ffmpeg...`);
+      await execFileAsync("ffmpeg", [
+        "-i",
+        audioPath,
+        "-ar",
+        String(SAMPLE_RATE),
+        "-ac",
+        "1",
+        "-f",
+        "wav",
+        "-acodec",
+        "pcm_f32le",
+        "-y",
+        tempPath
+      ], {
+        env: { PATH: process.env.PATH, HOME: process.env.HOME, LANG: process.env.LANG, TMPDIR: process.env.TMPDIR }
+      });
+      await chmod(tempPath, 384).catch(() => {
+      });
+      this.log("ffmpeg conversion complete, parsing WAV...");
+      return await this.parseWavFile(tempPath);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to convert audio file with ffmpeg: ${msg}`);
+    } finally {
+      try {
+        await unlink(tempPath);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Process buffered audio through Whisper
+   */
+  async processBufferedAudio(force = false) {
+    if (this.isProcessing) {
+      return;
+    }
+    if (!force && this.totalBufferDuration < CHUNK_DURATION_MS) {
+      return;
+    }
+    if (this.audioBuffer.length === 0) {
+      return;
+    }
+    if (!this.whisperModule) {
+      this.logError("Cannot process: Whisper module not loaded");
+      return;
+    }
+    this.isProcessing = true;
+    const processStartTime = this.bufferStartTime;
+    try {
+      const totalSamples = this.audioBuffer.reduce((sum, arr) => sum + arr.length, 0);
+      const combinedAudio = new Float32Array(totalSamples);
+      let offset = 0;
+      for (const chunk of this.audioBuffer) {
+        combinedAudio.set(chunk, offset);
+        offset += chunk.length;
+      }
+      const processedDuration = this.totalBufferDuration;
+      this.audioBuffer = [];
+      this.totalBufferDuration = 0;
+      this.totalBufferBytes = 0;
+      this.bufferStartTime = Date.now();
+      this.log(`Processing ${Math.round(processedDuration)}ms of audio...`);
+      const result = await this.whisperModule.whisper(combinedAudio, {
+        modelPath: this.config.modelPath,
+        language: this.config.language,
+        threads: this.config.threads,
+        translate: this.config.translateToEnglish
+      });
+      if (result && result.length > 0) {
+        for (const segment of result) {
+          const transcriptResult = {
+            text: segment.text.trim(),
+            startTime: processStartTime / 1e3 + segment.start,
+            endTime: processStartTime / 1e3 + segment.end,
+            confidence: 0.9
+            // Whisper doesn't provide confidence, use default
+          };
+          if (transcriptResult.text) {
+            this.transcriptCallbacks.forEach((cb) => cb(transcriptResult));
+            this.emit("transcript", transcriptResult);
+            const preview = transcriptResult.text.length > 50 ? `${transcriptResult.text.substring(0, 50)}...` : transcriptResult.text;
+            this.log(`Transcript: "${preview}"`);
+          }
+        }
+      }
+    } catch (error) {
+      const transcriptionError = new Error(`Whisper transcription failed: ${error.message}`);
+      this.errorCallbacks.forEach((cb) => cb(transcriptionError));
+      this.emit("error", transcriptionError);
+      this.logError("Transcription error", error);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Log helper
+   */
+  log(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    console.log(`[WhisperService ${timestamp}] ${message}`);
+  }
+  /**
+   * Error log helper
+   */
+  logError(message, error) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const errorStr = error instanceof Error ? error.message : String(error);
+    console.error(`[WhisperService ${timestamp}] ERROR: ${message} - ${errorStr}`);
+  }
+  getRequiredMemoryBytes() {
+    const modelName = basename2(this.config.modelPath);
+    return MODEL_MEMORY_REQUIREMENTS_BYTES[modelName] ?? MODEL_MEMORY_REQUIREMENTS_BYTES["ggml-small.bin"];
+  }
+};
+var whisperService = new WhisperService();
+
+// src/main/output/templates/registry.ts
+var TemplateRegistryImpl = class {
+  templates = /* @__PURE__ */ new Map();
+  /**
+   * Register a template. Overwrites any existing template with the same name.
+   */
+  register(template) {
+    this.templates.set(template.name, template);
+  }
+  /**
+   * Get a template by name. Returns undefined if not found.
+   */
+  get(name) {
+    return this.templates.get(name);
+  }
+  /**
+   * Check if a template with the given name exists.
+   */
+  has(name) {
+    return this.templates.has(name);
+  }
+  /**
+   * List all registered template names.
+   */
+  list() {
+    return Array.from(this.templates.keys());
+  }
+  /**
+   * List all registered templates with their descriptions.
+   */
+  listWithDescriptions() {
+    return Array.from(this.templates.values()).map((t) => ({
+      name: t.name,
+      description: t.description,
+      fileExtension: t.fileExtension
+    }));
+  }
+  /**
+   * Get the default template name.
+   */
+  getDefault() {
+    return "markdown";
+  }
+};
+var templateRegistry = new TemplateRegistryImpl();
+
+// src/main/output/templates/helpers.ts
+import * as path3 from "path";
+function formatTimestamp(seconds) {
+  const totalSeconds = Math.max(0, Math.floor(seconds));
+  const mins = Math.floor(totalSeconds / 60);
+  const secs = totalSeconds % 60;
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const mins = Math.floor(totalSeconds / 60);
+  const secs = totalSeconds % 60;
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function formatDate(date) {
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const month = months[date.getMonth()];
+  const day = date.getDate();
+  const year = date.getFullYear();
+  const rawHours = date.getHours();
+  const ampm = rawHours >= 12 ? "PM" : "AM";
+  const hours = rawHours % 12 || 12;
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  return `${month} ${day}, ${year} at ${hours}:${minutes} ${ampm}`;
+}
+function generateSegmentTitle(text) {
+  const firstSentence = text.split(/[.!?]/)[0].trim();
+  if (firstSentence.length <= 60) return firstSentence;
+  return firstSentence.slice(0, 57) + "...";
+}
+function wrapTranscription(transcription) {
+  if (!transcription.includes(".") && !transcription.includes("!") && !transcription.includes("?")) {
+    return transcription;
+  }
+  const sentences = transcription.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+  if (sentences.length <= 1) return transcription;
+  return sentences.join("\n> ");
+}
+function computeRelativeFramePath(framePath, sessionDir) {
+  if (!path3.isAbsolute(framePath)) {
+    return framePath;
+  }
+  return path3.relative(sessionDir, framePath);
+}
+function computeSessionDuration(segments) {
+  if (segments.length === 0) return "0:00";
+  return formatDuration(
+    (segments[segments.length - 1].endTime - segments[0].startTime) * 1e3
+  );
+}
+function mapFramesToSegments(segments, frames) {
+  const map = /* @__PURE__ */ new Map();
+  for (const frame of frames) {
+    let bestIndex = 0;
+    let bestDistance = Infinity;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (frame.timestamp >= seg.startTime && frame.timestamp <= seg.endTime) {
+        bestIndex = i;
+        bestDistance = 0;
+        break;
+      }
+      const distance = Math.abs(frame.timestamp - seg.startTime);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestIndex = i;
+      }
+    }
+    const existing = map.get(bestIndex) || [];
+    existing.push(frame);
+    map.set(bestIndex, existing);
+  }
+  for (const [, frameList] of map) {
+    frameList.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  return map;
+}
+
+// src/main/output/templates/markdown.ts
+var REPORT_SUPPORT_LINE2 = "*If this report saved you time, support development: [Ko-fi](https://ko-fi.com/eddiesanjuan)*";
+var markdownTemplate = {
+  name: "markdown",
+  description: "Default Markdown format \u2014 AI-ready, llms.txt-inspired structured document",
+  fileExtension: ".md",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const sessionDuration = computeSessionDuration(transcriptSegments);
+    let md = `# markupr Session \u2014 ${sessionTimestamp}
+`;
+    md += `> Segments: ${transcriptSegments.length} | Frames: ${extractedFrames.length} | Duration: ${sessionDuration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No speech was detected during this recording._
+`;
+      return { content: md, fileExtension: ".md" };
+    }
+    md += `## Transcript
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      md += `### [${formattedTime}] ${title}
+`;
+      md += `> ${wrapTranscription(segment.text)}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const frameTimestamp = formatTimestamp(frame.timestamp);
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Frame at ${frameTimestamp}](${relativePath})
+
+`;
+        }
+      }
+    }
+    md += `---
+*Generated by [markupr](https://markupr.com)*
+${REPORT_SUPPORT_LINE2}
+`;
+    return { content: md, fileExtension: ".md" };
+  }
+};
+
+// src/main/output/templates/json.ts
+var jsonTemplate = {
+  name: "json",
+  description: "Structured JSON output for programmatic consumption",
+  fileExtension: ".json",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    const output = {
+      version: "1.0",
+      generator: "markupr",
+      timestamp: new Date(timestamp ?? Date.now()).toISOString(),
+      summary: {
+        segments: transcriptSegments.length,
+        frames: extractedFrames.length,
+        duration: computeSessionDuration(transcriptSegments)
+      },
+      segments: transcriptSegments.map((segment, i) => {
+        const frames = segmentFrameMap.get(i) || [];
+        return {
+          text: segment.text,
+          startTime: segment.startTime,
+          endTime: segment.endTime,
+          confidence: segment.confidence,
+          frames: frames.map((f) => ({
+            path: computeRelativeFramePath(f.path, sessionDir),
+            timestamp: f.timestamp,
+            reason: f.reason
+          }))
+        };
+      })
+    };
+    return {
+      content: JSON.stringify(output, null, 2),
+      fileExtension: ".json"
+    };
+  }
+};
+
+// src/main/output/templates/github-issue.ts
+var githubIssueTemplate = {
+  name: "github-issue",
+  description: "GitHub-flavored Markdown optimized for issue bodies with task lists and collapsible details",
+  fileExtension: ".md",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const duration = computeSessionDuration(transcriptSegments);
+    let md = `## Feedback Report
+
+`;
+    md += `> Captured by [markupr](https://markupr.com) on ${sessionTimestamp}
+`;
+    md += `> ${transcriptSegments.length} segments | ${extractedFrames.length} frames | Duration: ${duration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No feedback was captured during this recording._
+`;
+      return { content: md, fileExtension: ".md" };
+    }
+    md += `### Action Items
+
+`;
+    for (const segment of transcriptSegments) {
+      const title = generateSegmentTitle(segment.text);
+      md += `- [ ] ${title}
+`;
+    }
+    md += `
+`;
+    md += `### Details
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      md += `<details>
+`;
+      md += `<summary><strong>[${formattedTime}] ${title}</strong></summary>
+
+`;
+      md += `${segment.text}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Screenshot](${relativePath})
+
+`;
+        }
+      }
+      md += `</details>
+
+`;
+    }
+    md += `---
+_Generated by [markupr](https://markupr.com)_
+`;
+    return { content: md, fileExtension: ".md" };
+  }
+};
+
+// src/main/output/templates/linear.ts
+var linearTemplate = {
+  name: "linear",
+  description: "Linear-compatible Markdown for issue descriptions",
+  fileExtension: ".md",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const duration = computeSessionDuration(transcriptSegments);
+    let md = `**Feedback Report** \u2014 ${sessionTimestamp}
+`;
+    md += `${transcriptSegments.length} segments | ${extractedFrames.length} frames | Duration: ${duration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No feedback was captured during this recording._
+`;
+      return { content: md, fileExtension: ".md" };
+    }
+    md += `**Action Items**
+
+`;
+    for (const segment of transcriptSegments) {
+      const title = generateSegmentTitle(segment.text);
+      md += `- [ ] ${title}
+`;
+    }
+    md += `
+---
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      md += `### [${formattedTime}] ${title}
+
+`;
+      md += `> ${segment.text}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Screenshot](${relativePath})
+
+`;
+        }
+      }
+    }
+    md += `---
+_Captured by [markupr](https://markupr.com)_
+`;
+    return { content: md, fileExtension: ".md" };
+  }
+};
+
+// src/main/output/templates/jira.ts
+var jiraTemplate = {
+  name: "jira",
+  description: "Jira wiki markup with panels, tables, and {code} blocks",
+  fileExtension: ".jira",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const duration = computeSessionDuration(transcriptSegments);
+    let content = `h1. Feedback Report
+
+`;
+    content += `{panel:title=Session Info|borderStyle=solid|borderColor=#ccc}
+`;
+    content += `*Captured:* ${sessionTimestamp}
+`;
+    content += `*Segments:* ${transcriptSegments.length} | *Frames:* ${extractedFrames.length} | *Duration:* ${duration}
+`;
+    content += `{panel}
+
+`;
+    if (transcriptSegments.length === 0) {
+      content += `_No feedback was captured during this recording._
+`;
+      return { content, fileExtension: ".jira" };
+    }
+    content += `h2. Summary
+
+`;
+    content += `||#||Timestamp||Feedback||
+`;
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      content += `|${i + 1}|${formattedTime}|${title}|
+`;
+    }
+    content += `
+`;
+    content += `h2. Details
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      content += `h3. \\[${formattedTime}\\] ${title}
+
+`;
+      content += `{quote}
+${segment.text}
+{quote}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          content += `!${relativePath}|thumbnail!
+
+`;
+        }
+      }
+    }
+    content += `----
+_Generated by [markupr|https://markupr.com]_
+`;
+    return { content, fileExtension: ".jira" };
+  }
+};
+
+// src/main/output/templates/index.ts
+templateRegistry.register(markdownTemplate);
+templateRegistry.register(jsonTemplate);
+templateRegistry.register(githubIssueTemplate);
+templateRegistry.register(linearTemplate);
+templateRegistry.register(jiraTemplate);
+
+// src/cli/CLIPipeline.ts
+var CLIPipeline = class _CLIPipeline {
+  options;
+  log;
+  progress;
+  tempFiles = [];
+  activeProcesses = /* @__PURE__ */ new Set();
+  constructor(options, log2, progress) {
+    this.options = options;
+    this.log = log2;
+    this.progress = progress ?? (() => {
+    });
+  }
+  /**
+   * Run the full pipeline: audio extraction -> transcription -> analysis ->
+   * frame extraction -> markdown generation.
+   */
+  async run() {
+    try {
+      return await this.runPipeline();
+    } finally {
+      await this.cleanup();
+    }
+  }
+  async runPipeline() {
+    const startTime = Date.now();
+    await this.validateVideoFile();
+    if (!(this.options.audioPath && this.options.skipFrames)) {
+      await this.checkFfmpegAvailable();
+    }
+    try {
+      if (!existsSync3(this.options.outputDir)) {
+        mkdirSync2(this.options.outputDir, { recursive: true });
+      }
+    } catch (error) {
+      const code = error.code;
+      if (code === "EACCES") {
+        throw new CLIPipelineError(
+          `Permission denied: cannot create output directory: ${this.options.outputDir}`,
+          "user"
+        );
+      }
+      throw new CLIPipelineError(
+        `Cannot create output directory: ${this.options.outputDir} (${code})`,
+        "system"
+      );
+    }
+    this.progress("Extracting audio...");
+    const audioPath = await this.resolveAudioPath();
+    this.progress("Transcribing (this may take a while)...");
+    const segments = await this.transcribe(audioPath);
+    const analyzer = new TranscriptAnalyzer();
+    const keyMoments = analyzer.analyze(segments);
+    this.log(`  Found ${keyMoments.length} key moment(s)`);
+    let extractedFrames = [];
+    if (!this.options.skipFrames) {
+      this.progress("Extracting frames...");
+      extractedFrames = await this.extractFrames(keyMoments, segments);
+    } else {
+      this.log("  Frame extraction skipped (--no-frames)");
+    }
+    this.progress("Generating report...");
+    const result = {
+      transcriptSegments: segments,
+      extractedFrames,
+      reportPath: this.options.outputDir
+    };
+    let reportContent;
+    let reportExtension = ".md";
+    const templateName = this.options.template;
+    if (templateName && templateName !== "markdown") {
+      const template = templateRegistry.get(templateName);
+      if (!template) {
+        const available = templateRegistry.list().join(", ");
+        throw new CLIPipelineError(
+          `Unknown template "${templateName}". Available: ${available}`,
+          "user"
+        );
+      }
+      const output = template.render({ result, sessionDir: this.options.outputDir });
+      reportContent = output.content;
+      reportExtension = output.fileExtension;
+    } else {
+      const generator = new MarkdownGeneratorImpl();
+      reportContent = generator.generateFromPostProcess(result, this.options.outputDir);
+    }
+    const outputFilename = this.generateOutputFilename(reportExtension);
+    const outputPath = join5(this.options.outputDir, outputFilename);
+    try {
+      await writeFile2(outputPath, reportContent, "utf-8");
+    } catch (error) {
+      const code = error.code;
+      throw new CLIPipelineError(
+        `Failed to write output file: ${outputPath}
+  Reason: ${code === "ENOSPC" ? "Disk is full" : error.message}`,
+        "system"
+      );
+    }
+    const durationSeconds = (Date.now() - startTime) / 1e3;
+    return {
+      outputPath,
+      transcriptSegments: segments.length,
+      extractedFrames: extractedFrames.length,
+      durationSeconds
+    };
+  }
+  /**
+   * Abort the pipeline: kill active child processes and clean up temp files.
+   */
+  async abort() {
+    for (const proc of this.activeProcesses) {
+      proc.kill("SIGTERM");
+    }
+    this.activeProcesses.clear();
+    await this.cleanup();
+  }
+  /**
+   * Clean up temp files created during the pipeline run.
+   */
+  async cleanup() {
+    for (const file of this.tempFiles) {
+      try {
+        await unlink2(file);
+      } catch {
+      }
+    }
+    this.tempFiles = [];
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  /**
+   * Execute a child process while tracking it for cleanup on abort.
+   */
+  static SAFE_CHILD_ENV = {
+    PATH: process.env.PATH,
+    HOME: process.env.HOME || process.env.USERPROFILE,
+    USERPROFILE: process.env.USERPROFILE,
+    LANG: process.env.LANG,
+    TMPDIR: process.env.TMPDIR || process.env.TEMP,
+    TEMP: process.env.TEMP
+  };
+  execFileTracked(command, args) {
+    return new Promise((resolve4, reject) => {
+      const child = execFileCb4(command, args, { env: _CLIPipeline.SAFE_CHILD_ENV }, (error, stdout, stderr) => {
+        this.activeProcesses.delete(child);
+        if (error) reject(error);
+        else resolve4({ stdout: stdout?.toString() ?? "", stderr: stderr?.toString() ?? "" });
+      });
+      this.activeProcesses.add(child);
+    });
+  }
+  /**
+   * Validate the video file is a real, non-empty file with a video stream.
+   */
+  async validateVideoFile() {
+    const { videoPath } = this.options;
+    let stats;
+    try {
+      stats = await stat3(videoPath);
+    } catch {
+      throw new CLIPipelineError(`Video file not found: ${videoPath}`, "user");
+    }
+    if (!stats.isFile()) {
+      throw new CLIPipelineError(`Not a regular file: ${videoPath}`, "user");
+    }
+    if (stats.size === 0) {
+      throw new CLIPipelineError(`Video file is empty (0 bytes): ${videoPath}`, "user");
+    }
+    try {
+      const { stdout } = await this.execFileTracked("ffprobe", [
+        "-v",
+        "error",
+        "-select_streams",
+        "v",
+        "-show_entries",
+        "stream=codec_type",
+        "-of",
+        "csv=p=0",
+        videoPath
+      ]);
+      if (!stdout.trim().includes("video")) {
+        throw new CLIPipelineError(
+          `No video stream found in file: ${videoPath}`,
+          "user"
+        );
+      }
+    } catch (error) {
+      if (error instanceof CLIPipelineError) throw error;
+      throw new CLIPipelineError(
+        `Cannot read video file (is ffprobe installed?): ${videoPath}`,
+        "system"
+      );
+    }
+  }
+  /**
+   * Check that ffmpeg is available on PATH.
+   */
+  async checkFfmpegAvailable() {
+    try {
+      await this.execFileTracked("ffmpeg", ["-version"]);
+    } catch {
+      const platform = process.platform;
+      const installHint = platform === "darwin" ? "brew install ffmpeg" : platform === "win32" ? "winget install ffmpeg (or download from https://ffmpeg.org)" : "apt install ffmpeg (or your package manager)";
+      throw new CLIPipelineError(
+        `ffmpeg is required but not found on your system.
+  Install via: ${installHint}
+  Or provide a separate audio file with --audio <file> and --no-frames`,
+        "system"
+      );
+    }
+  }
+  /**
+   * Resolve the audio path. If no separate audio file was provided, probe
+   * the video for an audio track and extract it to a temp WAV file.
+   */
+  async resolveAudioPath() {
+    if (this.options.audioPath) {
+      if (!existsSync3(this.options.audioPath)) {
+        throw new CLIPipelineError(
+          `Audio file not found: ${this.options.audioPath}`,
+          "user"
+        );
+      }
+      this.log(`  Using provided audio: ${this.options.audioPath}`);
+      return this.options.audioPath;
+    }
+    const hasAudio = await this.videoHasAudioTrack(this.options.videoPath);
+    if (!hasAudio) {
+      this.log("  No audio track found in video - transcription will be skipped");
+      return null;
+    }
+    this.log("  Extracting audio from video...");
+    const tempAudioPath = join5(tmpdir2(), `markupr-cli-audio-${randomUUID2()}.wav`);
+    this.tempFiles.push(tempAudioPath);
+    try {
+      await this.execFileTracked("ffmpeg", [
+        "-i",
+        this.options.videoPath,
+        "-vn",
+        "-ar",
+        "16000",
+        "-ac",
+        "1",
+        "-f",
+        "wav",
+        "-acodec",
+        "pcm_f32le",
+        "-y",
+        tempAudioPath
+      ]);
+      await chmod2(tempAudioPath, 384).catch(() => {
+      });
+      this.log("  Audio extraction complete");
+      return tempAudioPath;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.log(`  WARNING: Audio extraction failed: ${msg}`);
+      return null;
+    }
+  }
+  /**
+   * Use ffprobe to check whether the video file contains an audio stream.
+   */
+  async videoHasAudioTrack(videoPath) {
+    try {
+      const { stdout } = await this.execFileTracked("ffprobe", [
+        "-v",
+        "error",
+        "-select_streams",
+        "a",
+        "-show_entries",
+        "stream=codec_type",
+        "-of",
+        "csv=p=0",
+        videoPath
+      ]);
+      return stdout.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Transcribe audio using WhisperService. Falls back gracefully if the
+   * model is not available.
+   */
+  async transcribe(audioPath) {
+    if (!audioPath) {
+      this.log("  No audio available - skipping transcription");
+      return [];
+    }
+    const whisper = new WhisperService(
+      this.options.whisperModelPath ? { modelPath: this.options.whisperModelPath } : void 0
+    );
+    if (!whisper.isModelAvailable()) {
+      const modelsDir = whisper.getModelsDirectory();
+      this.log(`  Whisper model not found at: ${whisper.getConfig().modelPath}`);
+      this.log(`  Models directory: ${modelsDir}`);
+      this.log("  Transcription will be skipped. Download a model to enable transcription.");
+      return [];
+    }
+    this.log(`  Transcribing with Whisper (model: ${basename3(whisper.getConfig().modelPath)})...`);
+    try {
+      const results = await whisper.transcribeFile(audioPath, (percent) => {
+        if (this.options.verbose) {
+          process.stdout.write(`\r  Transcription progress: ${percent}%`);
+        }
+      });
+      if (this.options.verbose && results.length > 0) {
+        process.stdout.write("\n");
+      }
+      const segments = results.map((r) => ({
+        text: r.text,
+        startTime: r.startTime,
+        endTime: r.endTime,
+        confidence: r.confidence
+      }));
+      this.log(`  Transcription complete: ${segments.length} segment(s)`);
+      return segments;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.log(`  WARNING: Transcription failed: ${msg}`);
+      return [];
+    }
+  }
+  /**
+   * Extract video frames at key moment timestamps.
+   */
+  async extractFrames(keyMoments, segments) {
+    if (keyMoments.length === 0) {
+      this.log("  No key moments found - skipping frame extraction");
+      return [];
+    }
+    const extractor = new FrameExtractor();
+    const available = await extractor.checkFfmpeg();
+    if (!available) {
+      this.log("  WARNING: ffmpeg not found - frame extraction skipped");
+      this.log("  Install ffmpeg: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)");
+      return [];
+    }
+    this.log(`  Extracting ${keyMoments.length} frame(s)...`);
+    const timestamps = keyMoments.map((m) => m.timestamp);
+    const extractionResult = await extractor.extract({
+      videoPath: this.options.videoPath,
+      timestamps,
+      outputDir: this.options.outputDir
+    });
+    const extractedFrames = extractionResult.frames.filter((f) => f.success).map((frame) => {
+      const moment = keyMoments.find(
+        (m) => Math.abs(m.timestamp - frame.timestamp) < 0.5
+      );
+      const closestSegment = this.findClosestSegment(frame.timestamp, segments);
+      return {
+        path: frame.path,
+        timestamp: frame.timestamp,
+        reason: moment?.reason ?? "Extracted frame",
+        transcriptSegment: closestSegment
+      };
+    });
+    this.log(`  Extracted ${extractedFrames.length} frame(s)`);
+    return extractedFrames;
+  }
+  /**
+   * Find the transcript segment closest to a given timestamp.
+   */
+  findClosestSegment(timestamp, segments) {
+    if (segments.length === 0) return void 0;
+    for (const segment of segments) {
+      if (timestamp >= segment.startTime && timestamp <= segment.endTime) {
+        return segment;
+      }
+    }
+    let closest = segments[0];
+    let minDistance = Math.abs(timestamp - closest.startTime);
+    for (let i = 1; i < segments.length; i++) {
+      const distance = Math.abs(timestamp - segments[i].startTime);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closest = segments[i];
+      }
+    }
+    return closest;
+  }
+  /**
+   * Generate the output filename based on the video filename and current date (UTC).
+   */
+  generateOutputFilename(extension = ".md") {
+    const videoName = basename3(this.options.videoPath).replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-");
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = [
+      now.getUTCFullYear(),
+      String(now.getUTCMonth() + 1).padStart(2, "0"),
+      String(now.getUTCDate()).padStart(2, "0")
+    ].join("");
+    const timeStr = [
+      String(now.getUTCHours()).padStart(2, "0"),
+      String(now.getUTCMinutes()).padStart(2, "0"),
+      String(now.getUTCSeconds()).padStart(2, "0")
+    ].join("");
+    const ext = extension.startsWith(".") ? extension : `.${extension}`;
+    return `${videoName}-feedback-${dateStr}-${timeStr}${ext}`;
+  }
+};
+var CLIPipelineError = class extends Error {
+  severity;
+  constructor(message, severity) {
+    super(message);
+    this.name = "CLIPipelineError";
+    this.severity = severity;
+  }
+};
+
+// src/mcp/tools/captureWithVoice.ts
+function register2(server) {
+  server.tool(
+    "capture_with_voice",
+    "Record screen and voice for a specified duration, then run the full markupr pipeline to produce a structured feedback report.",
+    {
+      duration: z2.number().min(3).max(300).describe("Recording duration in seconds (3-300)"),
+      outputDir: z2.string().optional().describe("Output directory (default: session directory)"),
+      skipFrames: z2.boolean().optional().default(false).describe("Skip frame extraction"),
+      template: z2.string().optional().describe(
+        `Output template (default: markdown). Options: ${templateRegistry.list().join(", ")}`
+      )
+    },
+    async ({ duration, outputDir, skipFrames, template }) => {
+      try {
+        const session = await sessionStore.create();
+        const sessionDir = sessionStore.getSessionDir(session.id);
+        const videoPath = join6(sessionDir, "recording.mp4");
+        log(`Starting capture_with_voice: duration=${duration}s`);
+        await record({ duration, outputPath: videoPath });
+        const pipelineOutputDir = outputDir ?? sessionDir;
+        const pipeline = new CLIPipeline(
+          {
+            videoPath,
+            outputDir: pipelineOutputDir,
+            skipFrames,
+            template,
+            verbose: false
+          },
+          (msg) => log(msg)
+        );
+        const result = await pipeline.run();
+        await sessionStore.update(session.id, {
+          status: "complete",
+          endTime: Date.now(),
+          videoPath,
+          reportPath: result.outputPath
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `Recording complete: ${duration} seconds captured`,
+                "Pipeline results:",
+                `  Transcript segments: ${result.transcriptSegments}`,
+                `  Extracted frames: ${result.extractedFrames}`,
+                `  Processing time: ${result.durationSeconds.toFixed(1)}s`,
+                "",
+                `Report: ${result.outputPath}`,
+                `OUTPUT:${result.outputPath}`
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/analyzeVideo.ts
+import { z as z3 } from "zod";
+import { stat as stat4 } from "fs/promises";
+function register3(server) {
+  server.tool(
+    "analyze_video",
+    "Process an existing video file through the markupr pipeline. Generates a structured markdown report with transcript, key moments, and extracted frames.",
+    {
+      videoPath: z3.string().describe("Absolute path to the video file"),
+      audioPath: z3.string().optional().describe("Separate audio file path (if not embedded)"),
+      outputDir: z3.string().optional().describe("Output directory (default: session directory)"),
+      skipFrames: z3.boolean().optional().default(false).describe("Skip frame extraction"),
+      template: z3.string().optional().describe(
+        `Output template (default: markdown). Options: ${templateRegistry.list().join(", ")}`
+      )
+    },
+    async ({ videoPath, audioPath, outputDir, skipFrames, template }) => {
+      try {
+        let fileStats;
+        try {
+          fileStats = await stat4(videoPath);
+        } catch {
+          return {
+            content: [{ type: "text", text: `Error: Video file not found: ${videoPath}` }],
+            isError: true
+          };
+        }
+        if (!fileStats.isFile() || fileStats.size === 0) {
+          return {
+            content: [{ type: "text", text: `Error: Video file is empty or not a regular file: ${videoPath}` }],
+            isError: true
+          };
+        }
+        if (audioPath) {
+          try {
+            const audioStats = await stat4(audioPath);
+            if (!audioStats.isFile() || audioStats.size === 0) {
+              return {
+                content: [{ type: "text", text: `Error: Audio file is empty or not a regular file: ${audioPath}` }],
+                isError: true
+              };
+            }
+          } catch {
+            return {
+              content: [{ type: "text", text: `Error: Audio file not found: ${audioPath}` }],
+              isError: true
+            };
+          }
+        }
+        const session = await sessionStore.create();
+        const sessionDir = sessionStore.getSessionDir(session.id);
+        const pipelineOutputDir = outputDir ?? sessionDir;
+        log(`Analyzing video: ${videoPath}`);
+        const pipeline = new CLIPipeline(
+          {
+            videoPath,
+            audioPath,
+            outputDir: pipelineOutputDir,
+            skipFrames,
+            template,
+            verbose: false
+          },
+          (msg) => log(msg)
+        );
+        const result = await pipeline.run();
+        await sessionStore.update(session.id, {
+          status: "complete",
+          endTime: Date.now(),
+          videoPath,
+          reportPath: result.outputPath
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `Video analysis complete`,
+                "Pipeline results:",
+                `  Transcript segments: ${result.transcriptSegments}`,
+                `  Extracted frames: ${result.extractedFrames}`,
+                `  Processing time: ${result.durationSeconds.toFixed(1)}s`,
+                "",
+                `Report: ${result.outputPath}`,
+                `OUTPUT:${result.outputPath}`
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/analyzeScreenshot.ts
+import { z as z4 } from "zod";
+import { join as join7 } from "path";
+import { readFile as readFile3, unlink as unlink3 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { randomUUID as randomUUID3 } from "crypto";
+function register4(server) {
+  server.tool(
+    "analyze_screenshot",
+    "Take a screenshot and return it as an image for the AI to analyze visually. Returns the image data directly for vision analysis.",
+    {
+      display: z4.number().optional().default(1).describe("Display number (1-indexed)"),
+      question: z4.string().optional().describe("What to look for in the screenshot")
+    },
+    async ({ display, question }) => {
+      const tempPath = join7(tmpdir3(), `markupr-mcp-screenshot-${randomUUID3()}.png`);
+      try {
+        log(`Capturing screenshot for analysis: display=${display}`);
+        await capture({ display, outputPath: tempPath });
+        await optimize(tempPath);
+        const imageBuffer = await readFile3(tempPath);
+        const base64Data = imageBuffer.toString("base64");
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const description = question ? `Screenshot of display ${display} captured at ${timestamp}. Question: ${question}` : `Screenshot of display ${display} captured at ${timestamp}`;
+        return {
+          content: [
+            {
+              type: "image",
+              data: base64Data,
+              mimeType: "image/png"
+            },
+            {
+              type: "text",
+              text: description
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      } finally {
+        await unlink3(tempPath).catch(() => {
+        });
+      }
+    }
+  );
+}
+
+// src/mcp/tools/startRecording.ts
+import { z as z5 } from "zod";
+import { join as join8 } from "path";
+
+// src/mcp/session/ActiveRecording.ts
+var ActiveRecording = class {
+  current = null;
+  /**
+   * Start tracking a recording. Throws if one is already in progress.
+   */
+  start(sessionId, process2, videoPath) {
+    if (this.current !== null) {
+      throw new Error(
+        `Recording already in progress (session: ${this.current.sessionId}). Stop it before starting a new one.`
+      );
+    }
+    this.current = { sessionId, process: process2, videoPath };
+    log(`Active recording started: ${sessionId}`);
+  }
+  /**
+   * Stop tracking the current recording. Returns the session ID and video path.
+   * Throws if no recording is active.
+   */
+  stop() {
+    if (this.current === null) {
+      throw new Error("No recording in progress.");
+    }
+    const { sessionId, videoPath } = this.current;
+    this.current = null;
+    log(`Active recording stopped: ${sessionId}`);
+    return { sessionId, videoPath };
+  }
+  /**
+   * Check if a recording is currently active.
+   */
+  isRecording() {
+    return this.current !== null;
+  }
+  /**
+   * Get the current recording state (read-only), or null.
+   */
+  getCurrent() {
+    return this.current;
+  }
+};
+var activeRecording = new ActiveRecording();
+
+// src/mcp/tools/startRecording.ts
+function register5(server) {
+  server.tool(
+    "start_recording",
+    "Start a long-form screen+voice recording session. Returns a session ID that can be used with stop_recording.",
+    {
+      label: z5.string().optional().describe("Session label for organization")
+    },
+    async ({ label }) => {
+      try {
+        if (activeRecording.isRecording()) {
+          const current = activeRecording.getCurrent();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Recording already in progress (session: ${current?.sessionId}). Stop it before starting a new one.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const session = await sessionStore.create(label);
+        const sessionDir = sessionStore.getSessionDir(session.id);
+        const videoPath = join8(sessionDir, "recording.mp4");
+        log(`Starting long-form recording: session=${session.id}`);
+        const process2 = start({ outputPath: videoPath });
+        activeRecording.start(session.id, process2, videoPath);
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                "Recording started.",
+                `Session ID: ${session.id}`,
+                "Status: recording",
+                "Use stop_recording to end and process the recording."
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/stopRecording.ts
+import { z as z6 } from "zod";
+function register6(server) {
+  server.tool(
+    "stop_recording",
+    "Stop an active recording and run the full markupr pipeline on the captured video.",
+    {
+      sessionId: z6.string().optional().describe("Session ID (default: current active recording)"),
+      skipFrames: z6.boolean().optional().default(false).describe("Skip frame extraction"),
+      template: z6.string().optional().describe(
+        `Output template (default: markdown). Options: ${templateRegistry.list().join(", ")}`
+      )
+    },
+    async ({ sessionId: _requestedSessionId, skipFrames, template }) => {
+      try {
+        if (!activeRecording.isRecording()) {
+          return {
+            content: [{ type: "text", text: "Error: No recording in progress." }],
+            isError: true
+          };
+        }
+        const current = activeRecording.getCurrent();
+        if (!current) {
+          return {
+            content: [{ type: "text", text: "Error: No recording in progress." }],
+            isError: true
+          };
+        }
+        log(`Stopping recording: session=${current.sessionId}`);
+        await stop(current.process);
+        const { sessionId, videoPath } = activeRecording.stop();
+        await sessionStore.update(sessionId, { status: "processing" });
+        const sessionDir = sessionStore.getSessionDir(sessionId);
+        const pipeline = new CLIPipeline(
+          {
+            videoPath,
+            outputDir: sessionDir,
+            skipFrames,
+            template,
+            verbose: false
+          },
+          (msg) => log(msg)
+        );
+        const result = await pipeline.run();
+        await sessionStore.update(sessionId, {
+          status: "complete",
+          endTime: Date.now(),
+          videoPath,
+          reportPath: result.outputPath
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `Recording stopped and processed.`,
+                `Session: ${sessionId}`,
+                "Pipeline results:",
+                `  Transcript segments: ${result.transcriptSegments}`,
+                `  Extracted frames: ${result.extractedFrames}`,
+                `  Processing time: ${result.durationSeconds.toFixed(1)}s`,
+                "",
+                `Report: ${result.outputPath}`,
+                `OUTPUT:${result.outputPath}`
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/pushToLinear.ts
+import { z as z7 } from "zod";
+import { stat as stat5 } from "fs/promises";
+
+// src/integrations/linear/LinearIssueCreator.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/integrations/linear/types.ts
+var SEVERITY_TO_PRIORITY = {
+  Critical: 1,
+  High: 2,
+  Medium: 3,
+  Low: 4
+};
+var CATEGORY_TO_LABEL = {
+  "Bug": "Bug",
+  "UX Issue": "Improvement",
+  "Suggestion": "Feature",
+  "Performance": "Bug",
+  "Question": "Feature",
+  "General": "Feature"
+};
+
+// src/integrations/linear/LinearIssueCreator.ts
+var LINEAR_API_URL = "https://api.linear.app/graphql";
+var LinearIssueCreator = class {
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  /**
+   * Push a markupr report to Linear, creating one issue per feedback item.
+   */
+  async pushReport(reportPath, options) {
+    const markdown = await readFile4(reportPath, "utf-8");
+    const items = parseMarkdownReport(markdown);
+    const team = await this.resolveTeam(options.teamKey);
+    const labels = await this.getTeamLabels(team.id);
+    const result = {
+      teamKey: options.teamKey,
+      totalItems: items.length,
+      created: 0,
+      failed: 0,
+      issues: [],
+      dryRun: options.dryRun ?? false
+    };
+    for (const item of items) {
+      const labelName = CATEGORY_TO_LABEL[item.category] ?? "Feature";
+      const matchingLabel = labels.find(
+        (l) => l.name.toLowerCase() === labelName.toLowerCase()
+      );
+      const issueInput = {
+        title: `[${item.id}] ${item.title}`,
+        description: this.buildIssueDescription(item),
+        teamId: team.id,
+        priority: SEVERITY_TO_PRIORITY[item.severity] ?? 3,
+        labelIds: matchingLabel ? [matchingLabel.id] : void 0,
+        projectId: options.projectName ? await this.resolveProjectId(team.id, options.projectName) : void 0
+      };
+      if (options.dryRun) {
+        result.issues.push({
+          success: true,
+          issueId: `dry-run-${item.id}`,
+          identifier: `DRY-${item.id}`,
+          issueUrl: `https://linear.app/dry-run/${item.id}`
+        });
+        result.created++;
+        continue;
+      }
+      const issueResult = await this.createIssue(issueInput);
+      result.issues.push(issueResult);
+      if (issueResult.success) {
+        result.created++;
+      } else {
+        result.failed++;
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a single Linear issue via GraphQL.
+   */
+  async createIssue(input) {
+    const mutation = `
+      mutation IssueCreate($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue {
+            id
+            url
+            identifier
+          }
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        title: input.title,
+        description: input.description,
+        teamId: input.teamId,
+        priority: input.priority,
+        ...input.labelIds && { labelIds: input.labelIds },
+        ...input.projectId && { projectId: input.projectId }
+      }
+    };
+    try {
+      const data = await this.graphql(mutation, variables);
+      if (data.issueCreate.success) {
+        return {
+          success: true,
+          issueId: data.issueCreate.issue.id,
+          issueUrl: data.issueCreate.issue.url,
+          identifier: data.issueCreate.issue.identifier
+        };
+      }
+      return { success: false, error: "Linear API returned success: false" };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Resolve a team key (e.g., "ENG") to a team ID.
+   */
+  async resolveTeam(teamKey) {
+    const query = `
+      query Teams {
+        teams {
+          nodes {
+            id
+            key
+            name
+          }
+        }
+      }
+    `;
+    const data = await this.graphql(query);
+    const team = data.teams.nodes.find(
+      (t) => t.key.toLowerCase() === teamKey.toLowerCase()
+    );
+    if (!team) {
+      const available = data.teams.nodes.map((t) => t.key).join(", ");
+      throw new Error(
+        `Team "${teamKey}" not found. Available teams: ${available}`
+      );
+    }
+    return team;
+  }
+  /**
+   * Get all labels for a team.
+   */
+  async getTeamLabels(teamId) {
+    const query = `
+      query TeamLabels($teamId: String!) {
+        team(id: $teamId) {
+          labels {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    `;
+    const data = await this.graphql(query, { teamId });
+    return data.team.labels.nodes;
+  }
+  /**
+   * Resolve a project name to a project ID within a team.
+   */
+  async resolveProjectId(teamId, projectName) {
+    const query = `
+      query Projects($teamId: String!) {
+        team(id: $teamId) {
+          projects {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    `;
+    const data = await this.graphql(query, { teamId });
+    const project = data.team.projects.nodes.find(
+      (p) => p.name.toLowerCase() === projectName.toLowerCase()
+    );
+    return project?.id;
+  }
+  /**
+   * Build markdown description for a Linear issue from a feedback item.
+   */
+  buildIssueDescription(item) {
+    let desc = `## markupr Feedback: ${item.id}
+
+`;
+    desc += `**Severity:** ${item.severity}
+`;
+    desc += `**Category:** ${item.category}
+`;
+    desc += `**Timestamp:** ${item.timestamp}
+
+`;
+    desc += `### Description
+
+${item.description}
+
+`;
+    if (item.suggestedAction) {
+      desc += `### Suggested Action
+
+${item.suggestedAction}
+
+`;
+    }
+    if (item.screenshotPaths.length > 0) {
+      desc += `### Screenshots
+
+`;
+      desc += `_${item.screenshotPaths.length} screenshot(s) captured during session._
+`;
+      for (const path4 of item.screenshotPaths) {
+        desc += `- \`${path4}\`
+`;
+      }
+    }
+    desc += `
+---
+*Created by [markupr](https://markupr.com)*`;
+    return desc;
+  }
+  /**
+   * Execute a GraphQL request against the Linear API.
+   */
+  async graphql(query, variables) {
+    const response = await fetch(LINEAR_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: this.token
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Linear API error: ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    if (json.errors && json.errors.length > 0) {
+      throw new Error(`Linear GraphQL error: ${json.errors[0].message}`);
+    }
+    if (!json.data) {
+      throw new Error("Linear API returned no data");
+    }
+    return json.data;
+  }
+};
+function parseMarkdownReport(markdown) {
+  const items = [];
+  const itemPattern = /^### (FB-\d+): (.+)$/gm;
+  const matches = [];
+  let match;
+  while ((match = itemPattern.exec(markdown)) !== null) {
+    matches.push({ index: match.index, id: match[1], title: match[2] });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const start2 = matches[i].index;
+    const end = i + 1 < matches.length ? matches[i + 1].index : markdown.length;
+    const section = markdown.slice(start2, end);
+    const severity = extractField(section, "Severity") || "Medium";
+    const category = extractField(section, "Type") || "General";
+    const timestamp = extractField(section, "Timestamp") || "00:00";
+    const description = extractBlockquote(section);
+    const screenshotPaths = extractScreenshots(section);
+    const suggestedAction = extractSuggestedAction(section);
+    items.push({
+      id: matches[i].id,
+      title: matches[i].title,
+      severity,
+      category,
+      timestamp,
+      description,
+      screenshotPaths,
+      suggestedAction
+    });
+  }
+  return items;
+}
+function extractField(section, fieldName) {
+  const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, "m");
+  const match = section.match(pattern);
+  return match ? match[1].trim() : "";
+}
+function extractBlockquote(section) {
+  const whatHappened = section.match(/#### What Happened\s*\n([\s\S]*?)(?=\n####|\n---)/);
+  if (!whatHappened) return "";
+  const lines = whatHappened[1].split("\n").filter((line) => line.startsWith(">")).map((line) => line.replace(/^>\s*/, "").trim());
+  return lines.join(" ").trim();
+}
+function extractScreenshots(section) {
+  const paths = [];
+  const pattern = /!\[.*?\]\((.+?)\)/g;
+  let match;
+  while ((match = pattern.exec(section)) !== null) {
+    paths.push(match[1]);
+  }
+  return paths;
+}
+function extractSuggestedAction(section) {
+  const actionSection = section.match(/#### Suggested Next Step\s*\n-\s*(.+)/);
+  return actionSection ? actionSection[1].trim() : "";
+}
+
+// src/mcp/tools/pushToLinear.ts
+function register7(server) {
+  server.tool(
+    "push_to_linear",
+    "Push a markupr feedback report to Linear. Creates one issue per feedback item with priority mapping, labels, and full context.",
+    {
+      reportPath: z7.string().describe("Absolute path to the markupr markdown report"),
+      teamKey: z7.string().describe('Linear team key (e.g., "ENG", "DES")'),
+      token: z7.string().optional().describe("Linear API key (or set LINEAR_API_KEY env var)"),
+      projectName: z7.string().optional().describe("Linear project name to assign issues to"),
+      dryRun: z7.boolean().optional().default(false).describe("Preview what would be created without actually creating issues")
+    },
+    async ({ reportPath, teamKey, token, projectName, dryRun }) => {
+      try {
+        const apiToken = token || process.env.LINEAR_API_KEY;
+        if (!apiToken) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: No Linear API token provided. Pass via `token` parameter or set LINEAR_API_KEY env var."
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const stats = await stat5(reportPath);
+          if (!stats.isFile() || stats.size === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: Report file is empty or not a regular file: ${reportPath}`
+                }
+              ],
+              isError: true
+            };
+          }
+        } catch {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Report file not found: ${reportPath}`
+              }
+            ],
+            isError: true
+          };
+        }
+        log(`Pushing report to Linear: ${reportPath} \u2192 team ${teamKey}`);
+        const creator = new LinearIssueCreator(apiToken);
+        const result = await creator.pushReport(reportPath, {
+          token: apiToken,
+          teamKey,
+          projectName,
+          dryRun
+        });
+        const lines = [
+          dryRun ? "DRY RUN \u2014 no issues created" : "Push to Linear complete",
+          "",
+          `Team: ${teamKey}`,
+          `Total items: ${result.totalItems}`,
+          `Created: ${result.created}`,
+          `Failed: ${result.failed}`,
+          ""
+        ];
+        for (const issue of result.issues) {
+          if (issue.success) {
+            lines.push(
+              `  ${issue.identifier}: ${issue.issueUrl}`
+            );
+          } else {
+            lines.push(`  FAILED: ${issue.error}`);
+          }
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/pushToGitHub.ts
+import { z as z8 } from "zod";
+import { stat as stat6 } from "fs/promises";
+
+// src/integrations/github/GitHubIssueCreator.ts
+import { readFile as readFile5 } from "fs/promises";
+
+// src/integrations/github/types.ts
+var CATEGORY_LABELS = {
+  Bug: { name: "bug", color: "d73a4a", description: "Something isn't working" },
+  "UX Issue": { name: "ux", color: "e4e669", description: "User experience issue" },
+  Suggestion: { name: "enhancement", color: "a2eeef", description: "New feature or request" },
+  Performance: { name: "performance", color: "f9d0c4", description: "Performance issue" },
+  Question: { name: "question", color: "d876e3", description: "Further information is requested" },
+  General: { name: "feedback", color: "c5def5", description: "General feedback" }
+};
+var SEVERITY_LABELS = {
+  Critical: { name: "priority: critical", color: "b60205", description: "Critical priority" },
+  High: { name: "priority: high", color: "d93f0b", description: "High priority" },
+  Medium: { name: "priority: medium", color: "fbca04", description: "Medium priority" },
+  Low: { name: "priority: low", color: "0e8a16", description: "Low priority" }
+};
+var MARKUPR_LABEL = {
+  name: "markupr",
+  color: "6f42c1",
+  description: "Created from markupr feedback session"
+};
+
+// src/integrations/github/GitHubIssueCreator.ts
+var GITHUB_API = "https://api.github.com";
+async function resolveAuth(explicitToken) {
+  if (explicitToken) {
+    return { token: explicitToken, source: "flag" };
+  }
+  const envToken = process.env.GITHUB_TOKEN;
+  if (envToken) {
+    return { token: envToken, source: "env" };
+  }
+  try {
+    const { execSync } = await import("child_process");
+    const ghToken = execSync("gh auth token", { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (ghToken) {
+      return { token: ghToken, source: "gh-cli" };
+    }
+  } catch {
+  }
+  throw new Error(
+    "No GitHub token found. Provide one via:\n  --token <token>\n  GITHUB_TOKEN environment variable\n  gh auth login (GitHub CLI)"
+  );
+}
+function parseMarkuprReport(markdown) {
+  const items = [];
+  const itemPattern = /### (FB-\d{3}): (.+?)(?=\n)/g;
+  let match;
+  while ((match = itemPattern.exec(markdown)) !== null) {
+    const id = match[1];
+    const title = match[2].trim();
+    const startIndex = match.index;
+    const rest = markdown.slice(startIndex + match[0].length);
+    const nextSectionMatch = rest.match(/\n### FB-\d{3}:|(?=\n## [A-Z])/);
+    const itemBlock = nextSectionMatch ? rest.slice(0, nextSectionMatch.index) : rest;
+    const severity = extractField2(itemBlock, "Severity") || "Medium";
+    const category = extractField2(itemBlock, "Type") || "General";
+    const timestamp = extractField2(itemBlock, "Timestamp") || "00:00";
+    const transcription = extractTranscription(itemBlock);
+    const screenshotPaths = extractScreenshots2(itemBlock);
+    const suggestedAction = extractSuggestedAction2(itemBlock);
+    items.push({
+      id,
+      title,
+      category,
+      severity,
+      timestamp,
+      transcription,
+      screenshotPaths,
+      suggestedAction
+    });
+  }
+  return items;
+}
+function extractField2(block, fieldName) {
+  const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`);
+  const match = block.match(pattern);
+  return match ? match[1].trim() : void 0;
+}
+function extractTranscription(block) {
+  const whatHappenedIdx = block.indexOf("#### What Happened");
+  if (whatHappenedIdx === -1) return "";
+  const afterHeading = block.slice(whatHappenedIdx);
+  const nextHeading = afterHeading.indexOf("\n####", 5);
+  const section = nextHeading !== -1 ? afterHeading.slice(0, nextHeading) : afterHeading;
+  const lines = section.split("\n");
+  const quotedLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("> ")) {
+      quotedLines.push(trimmed.slice(2));
+    } else if (trimmed === ">") {
+      quotedLines.push("");
+    }
+  }
+  return quotedLines.join(" ").trim();
+}
+function extractScreenshots2(block) {
+  const paths = [];
+  const pattern = /!\[.*?\]\((.+?)\)/g;
+  let match;
+  while ((match = pattern.exec(block)) !== null) {
+    paths.push(match[1]);
+  }
+  return paths;
+}
+function extractSuggestedAction2(block) {
+  const idx = block.indexOf("#### Suggested Next Step");
+  if (idx === -1) return "";
+  const afterHeading = block.slice(idx + "#### Suggested Next Step".length);
+  const nextSection = afterHeading.indexOf("\n---");
+  const section = nextSection !== -1 ? afterHeading.slice(0, nextSection) : afterHeading;
+  const lines = section.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      return trimmed.slice(2);
+    }
+  }
+  return "";
+}
+function formatIssueBody(item, reportPath) {
+  let body = `## ${item.id}: ${item.title}
+
+`;
+  body += `| Field | Value |
+|-------|-------|
+`;
+  body += `| **Severity** | ${item.severity} |
+`;
+  body += `| **Category** | ${item.category} |
+`;
+  body += `| **Timestamp** | ${item.timestamp} |
+
+`;
+  body += `### What Happened
+
+`;
+  body += `> ${item.transcription}
+
+`;
+  if (item.screenshotPaths.length > 0) {
+    body += `### Screenshots
+
+`;
+    body += `_${item.screenshotPaths.length} screenshot(s) captured \u2014 see the markupr report for images._
+
+`;
+  }
+  if (item.suggestedAction) {
+    body += `### Suggested Action
+
+`;
+    body += `${item.suggestedAction}
+
+`;
+  }
+  body += `---
+`;
+  if (reportPath) {
+    body += `_Source: \`${reportPath}\`_
+`;
+  }
+  body += `_Created by [markupr](https://markupr.com)_
+`;
+  return body;
+}
+function getLabelsForItem(item) {
+  const labels = [MARKUPR_LABEL.name];
+  const categoryLabel = CATEGORY_LABELS[item.category];
+  if (categoryLabel) {
+    labels.push(categoryLabel.name);
+  }
+  const severityLabel = SEVERITY_LABELS[item.severity];
+  if (severityLabel) {
+    labels.push(severityLabel.name);
+  }
+  return labels;
+}
+function collectRequiredLabels(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const labels = [];
+  seen.add(MARKUPR_LABEL.name);
+  labels.push(MARKUPR_LABEL);
+  for (const item of items) {
+    const catLabel = CATEGORY_LABELS[item.category];
+    if (catLabel && !seen.has(catLabel.name)) {
+      seen.add(catLabel.name);
+      labels.push(catLabel);
+    }
+    const sevLabel = SEVERITY_LABELS[item.severity];
+    if (sevLabel && !seen.has(sevLabel.name)) {
+      seen.add(sevLabel.name);
+      labels.push(sevLabel);
+    }
+  }
+  return labels;
+}
+var GitHubAPIClient = class {
+  baseUrl;
+  headers;
+  constructor(auth, baseUrl = GITHUB_API) {
+    this.baseUrl = baseUrl;
+    this.headers = {
+      Authorization: `Bearer ${auth.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "Content-Type": "application/json",
+      "User-Agent": "markupr-github-integration"
+    };
+  }
+  async createIssue(repo, input) {
+    const url = `${this.baseUrl}/repos/${repo.owner}/${repo.repo}/issues`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        title: input.title,
+        body: input.body,
+        labels: input.labels
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`GitHub API error (${response.status}): ${text}`);
+    }
+    const data = await response.json();
+    return {
+      number: data.number,
+      url: data.html_url,
+      title: data.title
+    };
+  }
+  async ensureLabel(repo, label) {
+    const url = `${this.baseUrl}/repos/${repo.owner}/${repo.repo}/labels`;
+    const checkUrl = `${url}/${encodeURIComponent(label.name)}`;
+    const checkResponse = await fetch(checkUrl, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (checkResponse.ok) {
+      return false;
+    }
+    const createResponse = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        name: label.name,
+        color: label.color,
+        description: label.description
+      })
+    });
+    if (!createResponse.ok) {
+      if (createResponse.status === 422) {
+        return false;
+      }
+      const text = await createResponse.text();
+      throw new Error(`Failed to create label "${label.name}": ${text}`);
+    }
+    return true;
+  }
+  async verifyAccess(repo) {
+    const url = `${this.baseUrl}/repos/${repo.owner}/${repo.repo}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Repository ${repo.owner}/${repo.repo} not found (or no access)`);
+      }
+      if (response.status === 401) {
+        throw new Error("GitHub token is invalid or expired");
+      }
+      throw new Error(`Failed to access repository (${response.status})`);
+    }
+  }
+};
+async function pushToGitHub(options) {
+  const { repo, auth, reportPath, dryRun = false, items: filterIds } = options;
+  const markdown = await readFile5(reportPath, "utf-8");
+  let items = parseMarkuprReport(markdown);
+  if (items.length === 0) {
+    throw new Error("No feedback items found in the report. Is this a valid markupr report?");
+  }
+  if (filterIds && filterIds.length > 0) {
+    const filterSet = new Set(filterIds.map((id) => id.toUpperCase()));
+    items = items.filter((item) => filterSet.has(item.id));
+    if (items.length === 0) {
+      throw new Error(`None of the specified items (${filterIds.join(", ")}) found in the report`);
+    }
+  }
+  const result = {
+    created: [],
+    labelsCreated: [],
+    errors: [],
+    dryRun
+  };
+  if (dryRun) {
+    for (const item of items) {
+      const labels = getLabelsForItem(item);
+      result.created.push({
+        number: 0,
+        url: "",
+        title: `[${item.id}] ${item.title}`
+      });
+    }
+    result.labelsCreated = collectRequiredLabels(items).map((l) => l.name);
+    return result;
+  }
+  const client = new GitHubAPIClient(auth);
+  await client.verifyAccess(repo);
+  const requiredLabels = collectRequiredLabels(items);
+  for (const label of requiredLabels) {
+    try {
+      const created = await client.ensureLabel(repo, label);
+      if (created) {
+        result.labelsCreated.push(label.name);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.errors.push({ itemId: "labels", error: message });
+    }
+  }
+  for (const item of items) {
+    try {
+      const labels = getLabelsForItem(item);
+      const body = formatIssueBody(item, reportPath);
+      const issueResult = await client.createIssue(repo, {
+        title: `[${item.id}] ${item.title}`,
+        body,
+        labels
+      });
+      result.created.push(issueResult);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.errors.push({ itemId: item.id, error: message });
+    }
+  }
+  return result;
+}
+function parseRepoString(repoStr) {
+  const parts = repoStr.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid repository format: "${repoStr}". Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+
+// src/mcp/tools/pushToGitHub.ts
+function register8(server) {
+  server.tool(
+    "push_to_github",
+    "Create GitHub issues from a markupr feedback report. Each feedback item becomes a separate issue with labels and structured markdown.",
+    {
+      reportPath: z8.string().describe("Absolute path to the markupr markdown report"),
+      repo: z8.string().describe('Target GitHub repository in "owner/repo" format'),
+      token: z8.string().optional().describe("GitHub token (falls back to GITHUB_TOKEN env or gh CLI)"),
+      items: z8.array(z8.string()).optional().describe("Specific FB-XXX item IDs to push (default: all)"),
+      dryRun: z8.boolean().optional().default(false).describe("Preview what would be created without creating")
+    },
+    async ({ reportPath, repo, token, items, dryRun }) => {
+      try {
+        try {
+          const stats = await stat6(reportPath);
+          if (!stats.isFile()) {
+            return {
+              content: [{ type: "text", text: `Error: Not a file: ${reportPath}` }],
+              isError: true
+            };
+          }
+        } catch {
+          return {
+            content: [{ type: "text", text: `Error: Report not found: ${reportPath}` }],
+            isError: true
+          };
+        }
+        let parsedRepo;
+        try {
+          parsedRepo = parseRepoString(repo);
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true
+          };
+        }
+        let auth;
+        try {
+          auth = await resolveAuth(token);
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true
+          };
+        }
+        log(`Pushing to GitHub: ${repo} (auth: ${auth.source}, dryRun: ${dryRun})`);
+        const result = await pushToGitHub({
+          repo: parsedRepo,
+          auth,
+          reportPath,
+          dryRun,
+          items
+        });
+        const lines = [];
+        if (dryRun) {
+          lines.push(`Dry run \u2014 ${result.created.length} issue(s) would be created:`);
+          lines.push("");
+          for (const issue of result.created) {
+            lines.push(`  - ${issue.title}`);
+          }
+          if (result.labelsCreated.length > 0) {
+            lines.push("");
+            lines.push(`Labels to create: ${result.labelsCreated.join(", ")}`);
+          }
+        } else {
+          lines.push(`Created ${result.created.length} issue(s):`);
+          lines.push("");
+          for (const issue of result.created) {
+            lines.push(`  - #${issue.number}: ${issue.title}`);
+            lines.push(`    ${issue.url}`);
+          }
+          if (result.labelsCreated.length > 0) {
+            lines.push("");
+            lines.push(`Labels created: ${result.labelsCreated.join(", ")}`);
+          }
+        }
+        if (result.errors.length > 0) {
+          lines.push("");
+          lines.push(`Errors (${result.errors.length}):`);
+          for (const err of result.errors) {
+            lines.push(`  - ${err.itemId}: ${err.error}`);
+          }
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/resources/sessionResource.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server) {
+  server.resource(
+    "latest-session",
+    "session://latest",
+    { description: "Metadata for the most recent MCP recording session", mimeType: "application/json" },
+    async () => {
+      const session = await sessionStore.getLatest();
+      if (!session) {
+        return {
+          contents: [{
+            uri: "session://latest",
+            mimeType: "application/json",
+            text: JSON.stringify({ error: "No sessions found" })
+          }]
+        };
+      }
+      return {
+        contents: [{
+          uri: "session://latest",
+          mimeType: "application/json",
+          text: JSON.stringify(session, null, 2)
+        }]
+      };
+    }
+  );
+  server.resource(
+    "session-by-id",
+    new ResourceTemplate("session://{id}", { list: void 0 }),
+    { description: "Metadata for a specific MCP recording session", mimeType: "application/json" },
+    async (uri, variables) => {
+      const id = variables.id;
+      const session = await sessionStore.get(id);
+      if (!session) {
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify({ error: `Session not found: ${id}` })
+          }]
+        };
+      }
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(session, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/mcp/server.ts
+var VERSION = true ? "2.5.0" : "0.0.0-dev";
+function createServer() {
+  const server = new McpServer2({
+    name: "markupr",
+    version: VERSION
+  });
+  register(server);
+  register2(server);
+  register3(server);
+  register4(server);
+  register5(server);
+  register6(server);
+  register7(server);
+  register8(server);
+  registerResources(server);
+  return server;
+}
+
+// src/mcp/index.ts
+var VERSION2 = true ? "2.5.0" : "0.0.0-dev";
+log(`markupr MCP server v${VERSION2} starting...`);
+process.on("uncaughtException", (error) => {
+  log(`Uncaught exception: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  log(`Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+  process.exit(1);
+});
+try {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+} catch (error) {
+  log(`Failed to start MCP server: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+}