markupr 2.4.0 → 2.6.0

package/dist/mcp/index.mjs

@@ -247,8 +247,8 @@ var SessionStore = class {
 var sessionStore = new SessionStore();
 
 // src/mcp/tools/captureScreenshot.ts
-function register(server2) {
-  server2.tool(
+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.",
     {
@@ -1869,6 +1869,433 @@ var WhisperService = class extends EventEmitter {
 };
 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;
@@ -1936,12 +2363,29 @@ var CLIPipeline = class _CLIPipeline {
       extractedFrames,
       reportPath: this.options.outputDir
     };
-    const generator = new MarkdownGeneratorImpl();
-    const markdown = generator.generateFromPostProcess(result, this.options.outputDir);
-    const outputFilename = this.generateOutputFilename();
+    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, markdown, "utf-8");
+      await writeFile2(outputPath, reportContent, "utf-8");
     } catch (error) {
       const code = error.code;
       throw new CLIPipelineError(
@@ -2238,7 +2682,7 @@ var CLIPipeline = class _CLIPipeline {
   /**
    * Generate the output filename based on the video filename and current date (UTC).
    */
-  generateOutputFilename() {
+  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 = [
@@ -2251,7 +2695,8 @@ var CLIPipeline = class _CLIPipeline {
       String(now.getUTCMinutes()).padStart(2, "0"),
       String(now.getUTCSeconds()).padStart(2, "0")
     ].join("");
-    return `${videoName}-feedback-${dateStr}-${timeStr}.md`;
+    const ext = extension.startsWith(".") ? extension : `.${extension}`;
+    return `${videoName}-feedback-${dateStr}-${timeStr}${ext}`;
   }
 };
 var CLIPipelineError = class extends Error {
@@ -2264,16 +2709,19 @@ var CLIPipelineError = class extends Error {
 };
 
 // src/mcp/tools/captureWithVoice.ts
-function register2(server2) {
-  server2.tool(
+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")
+      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 }) => {
+    async ({ duration, outputDir, skipFrames, template }) => {
       try {
         const session = await sessionStore.create();
         const sessionDir = sessionStore.getSessionDir(session.id);
@@ -2286,6 +2734,7 @@ function register2(server2) {
             videoPath,
             outputDir: pipelineOutputDir,
             skipFrames,
+            template,
             verbose: false
           },
           (msg) => log(msg)
@@ -2327,17 +2776,20 @@ function register2(server2) {
 // src/mcp/tools/analyzeVideo.ts
 import { z as z3 } from "zod";
 import { stat as stat4 } from "fs/promises";
-function register3(server2) {
-  server2.tool(
+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")
+      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 }) => {
+    async ({ videoPath, audioPath, outputDir, skipFrames, template }) => {
       try {
         let fileStats;
         try {
@@ -2380,6 +2832,7 @@ function register3(server2) {
             audioPath,
             outputDir: pipelineOutputDir,
             skipFrames,
+            template,
             verbose: false
           },
           (msg) => log(msg)
@@ -2424,8 +2877,8 @@ 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(server2) {
-  server2.tool(
+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.",
     {
@@ -2516,8 +2969,8 @@ var ActiveRecording = class {
 var activeRecording = new ActiveRecording();
 
 // src/mcp/tools/startRecording.ts
-function register5(server2) {
-  server2.tool(
+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.",
     {
@@ -2568,15 +3021,18 @@ function register5(server2) {
 
 // src/mcp/tools/stopRecording.ts
 import { z as z6 } from "zod";
-function register6(server2) {
-  server2.tool(
+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")
+      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 }) => {
+    async ({ sessionId: _requestedSessionId, skipFrames, template }) => {
       try {
         if (!activeRecording.isRecording()) {
           return {
@@ -2601,6 +3057,7 @@ function register6(server2) {
             videoPath,
             outputDir: sessionDir,
             skipFrames,
+            template,
             verbose: false
           },
           (msg) => log(msg)
@@ -2640,43 +3097,1113 @@ function register6(server2) {
   );
 }
 
-// src/mcp/resources/sessionResource.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-function registerResources(server2) {
-  server2.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) {
+// 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 {
-          contents: [{
-            uri: "session://latest",
-            mimeType: "application/json",
-            text: JSON.stringify({ error: "No sessions found" })
-          }]
+          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 {
-        contents: [{
-          uri: "session://latest",
-          mimeType: "application/json",
-          text: JSON.stringify(session, null, 2)
-        }]
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-  );
-  server2.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: [{
+  }
+  /**
+   * 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/tools/describeScreen.ts
+import { z as z9 } from "zod";
+import { join as join9 } from "path";
+import { readFile as readFile6, unlink as unlink4, stat as stat7 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { randomUUID as randomUUID4 } from "crypto";
+import Anthropic from "@anthropic-ai/sdk";
+var DESCRIBE_SCREEN_PROMPT = `You are a screen description engine for AI coding agents. You receive a screenshot of a developer's screen and must describe what is visible in a structured, actionable way.
+
+## Output Structure
+
+Return a structured description with the following sections:
+
+### Active Window
+Identify the primary/focused application and its state (e.g., "VS Code with main.ts open", "Chrome showing localhost:3000").
+
+### Visible UI Elements
+List the key UI elements visible: buttons, inputs, navigation, modals, dialogs, sidebars, tabs, toolbars, etc. Be specific about labels and state (enabled/disabled, selected, etc.).
+
+### Text Content
+Extract any readable text: error messages, code snippets, terminal output, form content, headings, notifications, toasts, etc. Quote verbatim when possible.
+
+### Layout Structure
+Briefly describe the spatial layout: panels, split views, columns, overlays, etc.
+
+### Notable Issues
+Flag anything that looks like a problem: error dialogs, red indicators, broken layouts, console errors, failed builds, stack traces, etc. If nothing looks wrong, say "None observed."
+
+## Rules
+1. Be factual and precise. Describe what you SEE, do not speculate about intent.
+2. Use developer-friendly terminology (e.g., "modal dialog" not "popup box").
+3. If text is partially obscured, note what is readable and indicate truncation with [...].
+4. Keep the description concise but thorough. Every line should be useful to an AI agent trying to understand the screen context.
+5. Do not wrap your response in markdown code fences. Return plain structured text.`;
+function register9(server) {
+  server.tool(
+    "describe_screen",
+    "Capture a screenshot (or read an existing image) and return a structured text description of what is visible on screen. Useful for giving AI agents visual context about UI state, errors, layout, and text content.",
+    {
+      imagePath: z9.string().optional().describe(
+        "Absolute path to an existing screenshot/image file. If omitted, a fresh screenshot is captured."
+      ),
+      display: z9.number().optional().default(1).describe("Display number to capture (1-indexed). Ignored when imagePath is provided."),
+      apiKey: z9.string().optional().describe(
+        "Anthropic API key. Falls back to ANTHROPIC_API_KEY env var."
+      ),
+      focus: z9.string().optional().describe(
+        'Optional focus area to pay extra attention to (e.g., "the error dialog", "the terminal output", "the sidebar navigation").'
+      )
+    },
+    async ({ imagePath, display, apiKey, focus }) => {
+      const resolvedKey = apiKey || process.env.ANTHROPIC_API_KEY;
+      if (!resolvedKey) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: No Anthropic API key provided. Pass via `apiKey` parameter or set ANTHROPIC_API_KEY env var."
+            }
+          ],
+          isError: true
+        };
+      }
+      let screenshotPath;
+      let tempPath;
+      try {
+        if (imagePath) {
+          let fileStats;
+          try {
+            fileStats = await stat7(imagePath);
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: Image file not found: ${imagePath}`
+                }
+              ],
+              isError: true
+            };
+          }
+          if (!fileStats.isFile() || fileStats.size === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: Image file is empty or not a regular file: ${imagePath}`
+                }
+              ],
+              isError: true
+            };
+          }
+          screenshotPath = imagePath;
+        } else {
+          tempPath = join9(
+            tmpdir4(),
+            `markupr-mcp-describe-${randomUUID4()}.png`
+          );
+          log(`Capturing screenshot for describe_screen: display=${display}`);
+          await capture({ display, outputPath: tempPath });
+          await optimize(tempPath);
+          screenshotPath = tempPath;
+        }
+        const imageBuffer = await readFile6(screenshotPath);
+        const base64Data = imageBuffer.toString("base64");
+        const ext = screenshotPath.split(".").pop()?.toLowerCase();
+        const mediaType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : ext === "gif" ? "image/gif" : "image/png";
+        log("Calling Claude API for screen description");
+        const client = new Anthropic({ apiKey: resolvedKey });
+        const userPrompt = focus ? `Describe what is visible on this screen. Pay special attention to: ${focus}` : "Describe what is visible on this screen.";
+        const response = await client.messages.create({
+          model: "claude-sonnet-4-5-20250929",
+          max_tokens: 2048,
+          temperature: 0.2,
+          system: DESCRIBE_SCREEN_PROMPT,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: mediaType,
+                    data: base64Data
+                  }
+                },
+                {
+                  type: "text",
+                  text: userPrompt
+                }
+              ]
+            }
+          ]
+        });
+        const textBlock = response.content.find(
+          (block) => block.type === "text"
+        );
+        if (!textBlock || textBlock.type !== "text") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: No text content in Claude response."
+              }
+            ],
+            isError: true
+          };
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const source = imagePath ? `image file: ${imagePath}` : `display ${display} capture`;
+        log("Screen description complete");
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `# Screen Description`,
+                `_Source: ${source} | ${timestamp}_`,
+                "",
+                textBlock.text
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error.message;
+        if (message.includes("401") || message.includes("authentication")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: Anthropic API authentication failed. Check your API key."
+              }
+            ],
+            isError: true
+          };
+        }
+        if (message.includes("429") || message.includes("rate")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: Anthropic API rate limit exceeded. Try again shortly."
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${message}`
+            }
+          ],
+          isError: true
+        };
+      } finally {
+        if (tempPath) {
+          await unlink4(tempPath).catch(() => {
+          });
+        }
+      }
+    }
+  );
+}
+
+// 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}` })
@@ -2695,25 +4222,41 @@ function registerResources(server2) {
 }
 
 // src/mcp/server.ts
-var VERSION = true ? "2.4.0" : "0.0.0-dev";
+var VERSION = true ? "2.6.0" : "0.0.0-dev";
 function createServer() {
-  const server2 = new McpServer2({
+  const server = new McpServer2({
     name: "markupr",
     version: VERSION
   });
-  register(server2);
-  register2(server2);
-  register3(server2);
-  register4(server2);
-  register5(server2);
-  register6(server2);
-  registerResources(server2);
-  return server2;
+  register(server);
+  register2(server);
+  register3(server);
+  register4(server);
+  register5(server);
+  register6(server);
+  register7(server);
+  register8(server);
+  register9(server);
+  registerResources(server);
+  return server;
 }
 
 // src/mcp/index.ts
-var VERSION2 = true ? "2.4.0" : "0.0.0-dev";
+var VERSION2 = true ? "2.6.0" : "0.0.0-dev";
 log(`markupr MCP server v${VERSION2} starting...`);
-var server = createServer();
-var transport = new StdioServerTransport();
-await server.connect(transport);
+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);
+}