@hugobatist/smartcode 0.1.0

package/dist/cli.js

@@ -0,0 +1,4324 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+function getVersion() {
+  if (cachedVersion) return cachedVersion;
+  const startDir = dirname(fileURLToPath(import.meta.url));
+  let dir = startDir;
+  for (let i = 0; i < 5; i++) {
+    try {
+      const pkgPath = join(dir, "package.json");
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.version) {
+        cachedVersion = pkg.version;
+        return cachedVersion;
+      }
+    } catch {
+    }
+    dir = dirname(dir);
+  }
+  cachedVersion = "0.0.0";
+  return cachedVersion;
+}
+var cachedVersion;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var log;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    log = {
+      info: (...args) => console.error(pc.blue("[smartcode]"), ...args),
+      warn: (...args) => console.error(pc.yellow("[smartcode]"), ...args),
+      error: (...args) => console.error(pc.red("[smartcode]"), ...args),
+      debug: (...args) => {
+        if (process.env["DEBUG"]) console.error(pc.dim("[smartcode]"), ...args);
+      }
+    };
+  }
+});
+
+// src/diagram/annotations.ts
+function isAnnotationStart(line) {
+  return line === ANNOTATION_START || line === ANNOTATION_START_LEGACY;
+}
+function parseAllAnnotations(content) {
+  const flags = /* @__PURE__ */ new Map();
+  const statuses = /* @__PURE__ */ new Map();
+  const breakpoints = /* @__PURE__ */ new Set();
+  const risks = /* @__PURE__ */ new Map();
+  const ghosts = [];
+  const lines = content.split("\n");
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (isAnnotationStart(trimmed)) {
+      inBlock = true;
+      continue;
+    }
+    if (trimmed === ANNOTATION_END) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock || trimmed === "") continue;
+    let match = FLAG_REGEX.exec(trimmed);
+    if (match) {
+      flags.set(match[1], { nodeId: match[1], message: match[2] });
+      continue;
+    }
+    match = STATUS_REGEX.exec(trimmed);
+    if (match) {
+      const statusValue = match[2];
+      if (VALID_STATUSES.includes(statusValue)) {
+        statuses.set(match[1], statusValue);
+      } else {
+        log.debug(`Skipping invalid status value: ${statusValue}`);
+      }
+      continue;
+    }
+    match = BREAKPOINT_REGEX.exec(trimmed);
+    if (match) {
+      breakpoints.add(match[1]);
+      continue;
+    }
+    match = RISK_REGEX.exec(trimmed);
+    if (match) {
+      risks.set(match[1], { nodeId: match[1], level: match[2], reason: match[3] });
+      continue;
+    }
+    match = GHOST_REGEX.exec(trimmed);
+    if (match) {
+      ghosts.push({ fromNodeId: match[1], toNodeId: match[2], label: match[3] });
+      continue;
+    }
+    log.debug(`Skipping unrecognized annotation line: ${trimmed}`);
+  }
+  return { flags, statuses, breakpoints, risks, ghosts };
+}
+function parseFlags(content) {
+  return parseAllAnnotations(content).flags;
+}
+function parseStatuses(content) {
+  return parseAllAnnotations(content).statuses;
+}
+function stripAnnotations(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (isAnnotationStart(trimmed)) {
+      inBlock = true;
+      continue;
+    }
+    if (trimmed === ANNOTATION_END) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock) {
+      result.push(line);
+    }
+  }
+  while (result.length > 0 && result[result.length - 1].trim() === "") {
+    result.pop();
+  }
+  return result.join("\n") + "\n";
+}
+function injectAnnotations(content, flags, statuses, breakpoints, risks, ghosts) {
+  const clean = stripAnnotations(content);
+  const hasFlags = flags.size > 0;
+  const hasStatuses = statuses !== void 0 && statuses.size > 0;
+  const hasBreakpoints = breakpoints !== void 0 && breakpoints.size > 0;
+  const hasRisks = risks !== void 0 && risks.size > 0;
+  const hasGhosts = ghosts !== void 0 && ghosts.length > 0;
+  if (!hasFlags && !hasStatuses && !hasBreakpoints && !hasRisks && !hasGhosts) {
+    return clean;
+  }
+  const lines = [
+    "",
+    ANNOTATION_START
+  ];
+  for (const [nodeId, flag] of flags) {
+    const escapedMessage = flag.message.replace(/"/g, "''");
+    lines.push(`%% @flag ${nodeId} "${escapedMessage}"`);
+  }
+  if (hasStatuses) {
+    for (const [nodeId, status] of statuses) {
+      lines.push(`%% @status ${nodeId} ${status}`);
+    }
+  }
+  if (hasBreakpoints) {
+    for (const nodeId of breakpoints) {
+      lines.push(`%% @breakpoint ${nodeId}`);
+    }
+  }
+  if (hasRisks) {
+    for (const [nodeId, risk] of risks) {
+      const escapedReason = risk.reason.replace(/"/g, "''");
+      lines.push(`%% @risk ${nodeId} ${risk.level} "${escapedReason}"`);
+    }
+  }
+  if (hasGhosts) {
+    for (const ghost of ghosts) {
+      const escapedLabel = ghost.label.replace(/"/g, "''");
+      lines.push(`%% @ghost ${ghost.fromNodeId} ${ghost.toNodeId} "${escapedLabel}"`);
+    }
+  }
+  lines.push(ANNOTATION_END);
+  lines.push("");
+  return clean.trimEnd() + "\n" + lines.join("\n");
+}
+var ANNOTATION_START, ANNOTATION_START_LEGACY, ANNOTATION_END, FLAG_REGEX, STATUS_REGEX, BREAKPOINT_REGEX, RISK_REGEX, GHOST_REGEX, VALID_STATUSES;
+var init_annotations = __esm({
+  "src/diagram/annotations.ts"() {
+    "use strict";
+    init_logger();
+    ANNOTATION_START = "%% --- ANNOTATIONS (auto-managed by SmartCode) ---";
+    ANNOTATION_START_LEGACY = "%% --- ANNOTATIONS (auto-managed by SmartB Diagrams) ---";
+    ANNOTATION_END = "%% --- END ANNOTATIONS ---";
+    FLAG_REGEX = /^%%\s*@flag\s+(\S+)\s+"([^"]*)"$/;
+    STATUS_REGEX = /^%%\s*@status\s+(\S+)\s+(\S+)$/;
+    BREAKPOINT_REGEX = /^%%\s*@breakpoint\s+(\S+)$/;
+    RISK_REGEX = /^%%\s*@risk\s+(\S+)\s+(high|medium|low)\s+"([^"]*)"$/;
+    GHOST_REGEX = /^%%\s*@ghost\s+(\S+)\s+(\S+)\s+"([^"]*)"$/;
+    VALID_STATUSES = ["ok", "problem", "in-progress", "discarded"];
+  }
+});
+
+// src/diagram/constants.ts
+var KNOWN_DIAGRAM_TYPES, SUBGRAPH_START, SUBGRAPH_END;
+var init_constants = __esm({
+  "src/diagram/constants.ts"() {
+    "use strict";
+    KNOWN_DIAGRAM_TYPES = [
+      "flowchart",
+      "graph",
+      "sequenceDiagram",
+      "classDiagram",
+      "stateDiagram",
+      "erDiagram",
+      "gantt",
+      "pie",
+      "gitgraph",
+      "mindmap",
+      "timeline"
+    ];
+    SUBGRAPH_START = /^\s*subgraph\s+([^\s\[]+)(?:\s*\["([^"]+)"\])?/;
+    SUBGRAPH_END = /^\s*end\s*$/;
+  }
+});
+
+// src/diagram/parser.ts
+function parseDiagramType(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("%%")) continue;
+    for (const diagramType of KNOWN_DIAGRAM_TYPES) {
+      if (trimmed === diagramType || trimmed.startsWith(diagramType + " ")) {
+        return diagramType;
+      }
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function parseDiagramContent(rawContent) {
+  const mermaidContent = stripAnnotations(rawContent);
+  const flags = parseFlags(rawContent);
+  const diagramType = parseDiagramType(mermaidContent);
+  return { mermaidContent, flags, diagramType };
+}
+var init_parser = __esm({
+  "src/diagram/parser.ts"() {
+    "use strict";
+    init_annotations();
+    init_constants();
+  }
+});
+
+// src/diagram/validator.ts
+function validateMermaidSyntax(content) {
+  const errors = [];
+  const trimmedContent = content.trim();
+  if (trimmedContent === "") {
+    return { valid: false, errors: [{ message: "Empty diagram content" }] };
+  }
+  const diagramType = parseDiagramType(content);
+  if (!diagramType) {
+    const firstLine = trimmedContent.split("\n")[0]?.trim() ?? "";
+    errors.push({
+      message: `Unknown diagram type. First line: "${firstLine}". Expected one of: ${KNOWN_DIAGRAM_TYPES.join(", ")}`,
+      line: 1
+    });
+    return { valid: false, errors, diagramType: void 0 };
+  }
+  const bracketErrors = checkBracketMatching(content);
+  errors.push(...bracketErrors);
+  const danglingErrors = checkDanglingArrows(content);
+  errors.push(...danglingErrors);
+  return {
+    valid: errors.length === 0,
+    errors,
+    diagramType
+  };
+}
+function checkBracketMatching(content) {
+  const errors = [];
+  const lines = content.split("\n");
+  const pairs = [["[", "]"], ["(", ")"], ["{", "}"]];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (line.trim().startsWith("%%")) continue;
+    for (const [open2, close] of pairs) {
+      let depth = 0;
+      for (const char of line) {
+        if (char === open2) depth++;
+        if (char === close) depth--;
+        if (depth < 0) {
+          errors.push({
+            message: `Unexpected closing '${close}' without matching '${open2}'`,
+            line: lineNum
+          });
+          break;
+        }
+      }
+      if (depth > 0) {
+        errors.push({
+          message: `Unclosed '${open2}' -- missing '${close}'`,
+          line: lineNum
+        });
+      }
+    }
+  }
+  return errors;
+}
+function checkDanglingArrows(content) {
+  const errors = [];
+  const lines = content.split("\n");
+  const danglingArrowPattern = /-->\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("%%")) continue;
+    if (danglingArrowPattern.test(trimmed)) {
+      errors.push({
+        message: `Dangling arrow -- line ends with '-->' but no target node`,
+        line: lineNum
+      });
+    }
+  }
+  return errors;
+}
+var init_validator = __esm({
+  "src/diagram/validator.ts"() {
+    "use strict";
+    init_parser();
+    init_constants();
+  }
+});
+
+// src/diagram/graph-types.ts
+var SHAPE_PATTERNS;
+var init_graph_types = __esm({
+  "src/diagram/graph-types.ts"() {
+    "use strict";
+    SHAPE_PATTERNS = [
+      { open: "([", close: "])", shape: "stadium" },
+      { open: "[[", close: "]]", shape: "subroutine" },
+      { open: "[(", close: ")]", shape: "cylinder" },
+      { open: "((", close: "))", shape: "circle" },
+      { open: "{{", close: "}}", shape: "hexagon" },
+      { open: "[/", close: "\\]", shape: "trapezoid" },
+      { open: "[\\", close: "/]", shape: "trapezoid-alt" },
+      { open: "[/", close: "/]", shape: "parallelogram" },
+      { open: "[\\", close: "\\]", shape: "parallelogram-alt" },
+      { open: ">", close: "]", shape: "asymmetric" },
+      { open: "{", close: "}", shape: "diamond" },
+      { open: "(", close: ")", shape: "rounded" },
+      { open: "[", close: "]", shape: "rect" }
+    ];
+  }
+});
+
+// src/diagram/graph-edge-parser.ts
+function stripInlineClass(ref) {
+  const classIdx = ref.indexOf(":::");
+  if (classIdx === -1) return { id: ref };
+  return {
+    id: ref.substring(0, classIdx),
+    className: ref.substring(classIdx + 3)
+  };
+}
+function parseNodeShape(definition) {
+  const trimmed = definition.trim();
+  if (!trimmed) return null;
+  const { id: withShape, className } = stripInlineClass(trimmed);
+  for (const sp of SHAPE_PATTERNS) {
+    const openIdx = withShape.indexOf(sp.open);
+    if (openIdx === -1) continue;
+    const nodeId = withShape.substring(0, openIdx).trim();
+    if (!nodeId || !/^[\w][\w\d_-]*$/.test(nodeId)) continue;
+    const afterOpen = withShape.substring(openIdx + sp.open.length);
+    if (!afterOpen.endsWith(sp.close)) continue;
+    const labelRaw = afterOpen.substring(0, afterOpen.length - sp.close.length);
+    let label = labelRaw;
+    if (label.startsWith('"') && label.endsWith('"')) {
+      label = label.substring(1, label.length - 1);
+    }
+    return { id: nodeId, label, shape: sp.shape, className };
+  }
+  return null;
+}
+function extractNodeSegments(line) {
+  let work = line;
+  for (const op of EDGE_OPS) {
+    work = work.replace(op.pattern, " \0 ");
+  }
+  return work.split("\0").map((s) => s.trim()).filter(Boolean);
+}
+function parseEdgesFromLine(line) {
+  const result = [];
+  let remaining = line;
+  let lastNode = null;
+  while (remaining.trim()) {
+    let earliest = null;
+    for (const op of EDGE_OPS) {
+      const match = op.pattern.exec(remaining);
+      if (match && (earliest === null || match.index < earliest.index)) {
+        earliest = {
+          index: match.index,
+          matchLen: match[0].length,
+          type: op.type,
+          bidirectional: op.bidirectional,
+          label: match[1]
+        };
+      }
+    }
+    if (!earliest) break;
+    const beforeOp = remaining.substring(0, earliest.index).trim();
+    remaining = remaining.substring(earliest.index + earliest.matchLen);
+    if (lastNode === null) {
+      lastNode = extractNodeId(beforeOp);
+      if (!lastNode) break;
+    }
+    const afterTrimmed = remaining.trim();
+    const nextNodeId = extractNodeId(afterTrimmed, "left");
+    if (!nextNodeId) break;
+    result.push({
+      from: lastNode,
+      to: nextNodeId,
+      type: earliest.type,
+      label: earliest.label,
+      bidirectional: earliest.bidirectional
+    });
+    lastNode = nextNodeId;
+    remaining = advancePastNode(remaining.trim(), nextNodeId);
+  }
+  return result;
+}
+function extractNodeId(text, direction = "right") {
+  if (!text.trim()) return null;
+  const { id } = stripInlineClass(text.trim());
+  const shaped = parseNodeShape(text.trim());
+  if (shaped) return shaped.id;
+  if (direction === "left") {
+    const match2 = /^([\w][\w\d_-]*)/.exec(id);
+    return match2 ? match2[1] : null;
+  }
+  const match = /([\w][\w\d_-]*)$/.exec(id);
+  return match ? match[1] : null;
+}
+function advancePastNode(text, nodeId) {
+  const { id: cleanText } = stripInlineClass(text);
+  for (const sp of SHAPE_PATTERNS) {
+    const expectedStart = nodeId + sp.open;
+    if (cleanText.startsWith(expectedStart)) {
+      const closeIdx = cleanText.indexOf(sp.close, expectedStart.length);
+      if (closeIdx !== -1) {
+        const afterClose = closeIdx + sp.close.length;
+        const afterWithClass = text.substring(afterClose);
+        const classMatch = /^:::\S+/.exec(afterWithClass);
+        return classMatch ? afterWithClass.substring(classMatch[0].length) : afterWithClass;
+      }
+    }
+  }
+  const safeId = regexSafe(nodeId);
+  const simplePattern = new RegExp(`^${safeId}(?::::\\S+)?`);
+  const simpleMatch = simplePattern.exec(text);
+  if (simpleMatch) {
+    return text.substring(simpleMatch[0].length);
+  }
+  return text.substring(nodeId.length);
+}
+function regexSafe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var EDGE_OPS;
+var init_graph_edge_parser = __esm({
+  "src/diagram/graph-edge-parser.ts"() {
+    "use strict";
+    init_graph_types();
+    EDGE_OPS = [
+      // Bidirectional variants (must come before unidirectional)
+      { pattern: /\s*<==>\s*/, type: "thick", bidirectional: true },
+      { pattern: /\s*<-\.->\s*/, type: "dotted", bidirectional: true },
+      { pattern: /\s*<-->\s*/, type: "arrow", bidirectional: true },
+      // Labeled edges: pipe syntax  -->|"label"|  or  -->|label|
+      { pattern: /\s*-->\|"([^"]*)"\|\s*/, type: "arrow", bidirectional: false },
+      { pattern: /\s*-->\|([^|]*)\|\s*/, type: "arrow", bidirectional: false },
+      // Labeled edges: inline syntax  -- "label" -->
+      { pattern: /\s*--\s*"([^"]*)"\s*-->\s*/, type: "arrow", bidirectional: false },
+      // Unlabeled operators (order: longest first)
+      { pattern: /\s*~~~\s*/, type: "invisible", bidirectional: false },
+      { pattern: /\s*==>\s*/, type: "thick", bidirectional: false },
+      { pattern: /\s*-\.->\s*/, type: "dotted", bidirectional: false },
+      { pattern: /\s*---\s*/, type: "open", bidirectional: false },
+      { pattern: /\s*-->\s*/, type: "arrow", bidirectional: false }
+    ];
+  }
+});
+
+// src/diagram/graph-parser.ts
+function parseMermaidToGraph(rawContent, filePath) {
+  const flags = parseFlags(rawContent);
+  const statuses = parseStatuses(rawContent);
+  const mermaidContent = stripAnnotations(rawContent);
+  const lines = mermaidContent.split("\n");
+  let diagramType = "flowchart";
+  let direction = "TB";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("%%")) continue;
+    const dirMatch = /^(flowchart|graph)\s+(TB|TD|BT|LR|RL)/.exec(trimmed);
+    if (dirMatch) {
+      diagramType = dirMatch[1];
+      const rawDir = dirMatch[2];
+      direction = rawDir === "TD" ? "TB" : rawDir;
+    }
+    break;
+  }
+  const classDefs = /* @__PURE__ */ new Map();
+  const nodeStyles = /* @__PURE__ */ new Map();
+  const linkStyles = /* @__PURE__ */ new Map();
+  const classAssignments = /* @__PURE__ */ new Map();
+  const directiveLineIndices = /* @__PURE__ */ new Set();
+  parseStyleDirectives(
+    lines,
+    classDefs,
+    nodeStyles,
+    linkStyles,
+    classAssignments,
+    directiveLineIndices
+  );
+  const subgraphs = /* @__PURE__ */ new Map();
+  const lineToSubgraph = /* @__PURE__ */ new Map();
+  const subgraphLineIndices = /* @__PURE__ */ new Set();
+  parseSubgraphStructure(lines, subgraphs, lineToSubgraph, subgraphLineIndices);
+  const nodes = /* @__PURE__ */ new Map();
+  parseNodeDefinitions(
+    lines,
+    nodes,
+    classAssignments,
+    lineToSubgraph,
+    directiveLineIndices,
+    subgraphLineIndices
+  );
+  const edges = [];
+  parseEdgeDefinitions(
+    lines,
+    edges,
+    nodes,
+    subgraphs,
+    lineToSubgraph,
+    directiveLineIndices,
+    subgraphLineIndices
+  );
+  for (const [nodeId, flag] of flags) {
+    const node = nodes.get(nodeId);
+    if (node) node.flag = flag;
+  }
+  for (const [nodeId, status] of statuses) {
+    const node = nodes.get(nodeId);
+    if (node) node.status = status;
+  }
+  const validation = validateMermaidSyntax(mermaidContent);
+  return {
+    diagramType,
+    direction,
+    nodes,
+    edges,
+    subgraphs,
+    classDefs,
+    nodeStyles,
+    linkStyles,
+    classAssignments,
+    filePath,
+    flags,
+    statuses,
+    validation
+  };
+}
+function parseStyleDirectives(lines, classDefs, nodeStyles, linkStyles, classAssignments, directiveLineIndices) {
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const classDefMatch = /^classDef\s+(\S+)\s+(.+);?\s*$/.exec(trimmed);
+    if (classDefMatch) {
+      const name = classDefMatch[1];
+      classDefs.set(name, classDefMatch[2].replace(/;\s*$/, ""));
+      directiveLineIndices.add(i);
+      continue;
+    }
+    const styleMatch = /^style\s+(\S+)\s+(.+);?\s*$/.exec(trimmed);
+    if (styleMatch) {
+      nodeStyles.set(styleMatch[1], styleMatch[2].replace(/;\s*$/, ""));
+      directiveLineIndices.add(i);
+      continue;
+    }
+    const linkStyleMatch = /^linkStyle\s+(\d+)\s+(.+);?\s*$/.exec(trimmed);
+    if (linkStyleMatch) {
+      linkStyles.set(
+        parseInt(linkStyleMatch[1], 10),
+        linkStyleMatch[2].replace(/;\s*$/, "")
+      );
+      directiveLineIndices.add(i);
+      continue;
+    }
+    const classDirectiveMatch = /^class\s+(.+?)\s+(\S+);?\s*$/.exec(trimmed);
+    if (classDirectiveMatch) {
+      const className = classDirectiveMatch[2].replace(/;\s*$/, "");
+      const nodeIds = classDirectiveMatch[1].split(",").map((s) => s.trim());
+      for (const nid of nodeIds) {
+        classAssignments.set(nid, className);
+      }
+      directiveLineIndices.add(i);
+      continue;
+    }
+  }
+}
+function parseSubgraphStructure(lines, subgraphs, lineToSubgraph, subgraphLineIndices) {
+  const subgraphStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const startMatch = SUBGRAPH_START.exec(line);
+    if (startMatch) {
+      const id = startMatch[1];
+      const label = startMatch[2] || id;
+      const parentId = subgraphStack.length > 0 ? subgraphStack[subgraphStack.length - 1] : null;
+      const sg = {
+        id,
+        label,
+        parentId,
+        nodeIds: [],
+        childSubgraphIds: []
+      };
+      subgraphs.set(id, sg);
+      if (parentId) {
+        const parent = subgraphs.get(parentId);
+        if (parent) parent.childSubgraphIds.push(id);
+      }
+      subgraphStack.push(id);
+      subgraphLineIndices.add(i);
+      continue;
+    }
+    if (SUBGRAPH_END.test(line) && subgraphStack.length > 0) {
+      subgraphStack.pop();
+      subgraphLineIndices.add(i);
+      continue;
+    }
+    if (subgraphStack.length > 0) {
+      lineToSubgraph.set(i, subgraphStack[subgraphStack.length - 1]);
+    }
+  }
+}
+function isSkippableLine(trimmed, lineIdx, directiveIndices, subgraphIndices) {
+  if (directiveIndices.has(lineIdx)) return true;
+  if (subgraphIndices.has(lineIdx)) return true;
+  if (!trimmed || trimmed.startsWith("%%")) return true;
+  if (DIRECTION_LINE.test(trimmed)) return true;
+  return false;
+}
+function parseNodeDefinitions(lines, nodes, classAssignments, lineToSubgraph, directiveLineIndices, subgraphLineIndices) {
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (isSkippableLine(trimmed, i, directiveLineIndices, subgraphLineIndices)) continue;
+    const nodeSegments = extractNodeSegments(trimmed);
+    for (const segment of nodeSegments) {
+      const parsed = parseNodeShape(segment);
+      if (parsed && !nodes.has(parsed.id)) {
+        const subgraphId = lineToSubgraph.get(i);
+        const cssClass = parsed.className || classAssignments.get(parsed.id);
+        nodes.set(parsed.id, {
+          id: parsed.id,
+          label: parsed.label,
+          shape: parsed.shape,
+          subgraphId,
+          cssClass
+        });
+        if (parsed.className) {
+          classAssignments.set(parsed.id, parsed.className);
+        }
+      } else if (!parsed) {
+        const { id: bareId, className } = stripInlineClass(segment.trim());
+        if (className && /^[\w][\w\d_-]*$/.test(bareId)) {
+          classAssignments.set(bareId, className);
+          if (!nodes.has(bareId)) {
+            nodes.set(bareId, {
+              id: bareId,
+              label: bareId,
+              shape: "rect",
+              subgraphId: lineToSubgraph.get(i),
+              cssClass: className
+            });
+          } else {
+            nodes.get(bareId).cssClass = className;
+          }
+        }
+      }
+    }
+  }
+}
+function parseEdgeDefinitions(lines, edges, nodes, subgraphs, lineToSubgraph, directiveLineIndices, subgraphLineIndices) {
+  const edgeIdCounts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (isSkippableLine(trimmed, i, directiveLineIndices, subgraphLineIndices)) continue;
+    const lineEdges = parseEdgesFromLine(trimmed);
+    for (const edgeInfo of lineEdges) {
+      const { id: fromId } = stripInlineClass(edgeInfo.from);
+      const { id: toId } = stripInlineClass(edgeInfo.to);
+      ensureNode(nodes, fromId, lineToSubgraph.get(i));
+      ensureNode(nodes, toId, lineToSubgraph.get(i));
+      const sgId = lineToSubgraph.get(i);
+      if (sgId) {
+        const sg = subgraphs.get(sgId);
+        if (sg) {
+          if (!sg.nodeIds.includes(fromId) && !subgraphs.has(fromId)) {
+            sg.nodeIds.push(fromId);
+          }
+          if (!sg.nodeIds.includes(toId) && !subgraphs.has(toId)) {
+            sg.nodeIds.push(toId);
+          }
+        }
+      }
+      const baseId = `${fromId}->${toId}`;
+      const count = edgeIdCounts.get(baseId) || 0;
+      const edgeId = count === 0 ? baseId : `${baseId}#${count}`;
+      edgeIdCounts.set(baseId, count + 1);
+      edges.push({
+        id: edgeId,
+        from: fromId,
+        to: toId,
+        type: edgeInfo.type,
+        label: edgeInfo.label,
+        bidirectional: edgeInfo.bidirectional || void 0
+      });
+    }
+  }
+}
+function ensureNode(nodes, id, subgraphId) {
+  if (nodes.has(id)) return;
+  nodes.set(id, { id, label: id, shape: "rect", subgraphId });
+}
+var DIRECTION_LINE;
+var init_graph_parser = __esm({
+  "src/diagram/graph-parser.ts"() {
+    "use strict";
+    init_annotations();
+    init_validator();
+    init_constants();
+    init_graph_edge_parser();
+    DIRECTION_LINE = /^(flowchart|graph)\s+(TB|TD|BT|LR|RL)/;
+  }
+});
+
+// src/utils/paths.ts
+import path from "path";
+import { existsSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getStaticDir() {
+  const prodPath = path.join(__dirname, "..", "static");
+  if (existsSync(prodPath)) return prodPath;
+  const devPath = path.join(__dirname, "..", "..", "static");
+  if (existsSync(devPath)) return devPath;
+  return prodPath;
+}
+function resolveProjectPath(projectRoot, filePath) {
+  const resolvedRoot = path.resolve(projectRoot);
+  const resolved = path.resolve(resolvedRoot, filePath);
+  if (!resolved.startsWith(resolvedRoot + path.sep) && resolved !== resolvedRoot) {
+    throw new Error(`Path traversal detected: ${filePath}`);
+  }
+  return resolved;
+}
+var __dirname;
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    __dirname = path.dirname(fileURLToPath2(import.meta.url));
+  }
+});
+
+// src/project/discovery.ts
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+async function discoverMmdFiles(directory) {
+  const entries = await readdir(directory, { recursive: true, withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".mmd")) continue;
+    const parentPath = entry.parentPath ?? "";
+    const relativePath = parentPath ? join2(parentPath, entry.name).slice(directory.length + 1) : entry.name;
+    const segments = relativePath.split("/");
+    const excluded = segments.some((seg) => EXCLUDED_DIRS.has(seg));
+    if (!excluded) {
+      files.push(relativePath);
+    }
+  }
+  return files.sort();
+}
+var EXCLUDED_DIRS;
+var init_discovery = __esm({
+  "src/project/discovery.ts"() {
+    "use strict";
+    EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "test",
+      "dist",
+      ".planning",
+      ".smartcode"
+    ]);
+  }
+});
+
+// src/diagram/service.ts
+var service_exports = {};
+__export(service_exports, {
+  DiagramService: () => DiagramService
+});
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var DiagramService;
+var init_service = __esm({
+  "src/diagram/service.ts"() {
+    "use strict";
+    init_parser();
+    init_annotations();
+    init_validator();
+    init_graph_parser();
+    init_paths();
+    init_discovery();
+    DiagramService = class {
+      constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+      }
+      /** Per-file write locks to serialize concurrent write operations */
+      writeLocks = /* @__PURE__ */ new Map();
+      /**
+       * Serialize write operations on a given file path.
+       * Each call waits for the previous write on the same file to finish before running.
+       * Cleans up lock entry when no further writes are queued.
+       */
+      async withWriteLock(filePath, fn) {
+        const prev = this.writeLocks.get(filePath) ?? Promise.resolve();
+        const current = prev.then(fn, fn);
+        const settled = current.then(() => {
+        }, () => {
+        });
+        this.writeLocks.set(filePath, settled);
+        const result = await current;
+        if (this.writeLocks.get(filePath) === settled) {
+          this.writeLocks.delete(filePath);
+        }
+        return result;
+      }
+      /**
+       * Read a .mmd file and parse all annotations + mermaid content in one pass.
+       */
+      async readAllAnnotations(filePath) {
+        const resolved = this.resolvePath(filePath);
+        const raw = await readFile(resolved, "utf-8");
+        const { mermaidContent } = parseDiagramContent(raw);
+        const { flags, statuses, breakpoints, risks, ghosts } = parseAllAnnotations(raw);
+        return { raw, mermaidContent, flags, statuses, breakpoints, risks, ghosts };
+      }
+      /**
+       * Read-modify-write cycle for annotation mutations.
+       * Acquires the write lock, reads all annotations, calls modifyFn to mutate them,
+       * then writes the result back.
+       */
+      async modifyAnnotation(filePath, modifyFn) {
+        return this.withWriteLock(filePath, async () => {
+          const data = await this.readAllAnnotations(filePath);
+          modifyFn(data);
+          await this._writeDiagramInternal(
+            filePath,
+            data.mermaidContent,
+            data.flags,
+            data.statuses,
+            data.breakpoints,
+            data.risks,
+            data.ghosts
+          );
+        });
+      }
+      /**
+       * Read and parse a .mmd file.
+       * Resolves path with traversal protection, parses content, and validates syntax.
+       */
+      async readDiagram(filePath) {
+        const resolved = this.resolvePath(filePath);
+        const raw = await readFile(resolved, "utf-8");
+        const { mermaidContent, diagramType } = parseDiagramContent(raw);
+        const { flags, statuses, breakpoints, risks, ghosts } = parseAllAnnotations(raw);
+        const validation = validateMermaidSyntax(mermaidContent);
+        if (diagramType && !validation.diagramType) {
+          validation.diagramType = diagramType;
+        }
+        return { raw, mermaidContent, flags, statuses, breakpoints, risks, ghosts, validation, filePath };
+      }
+      /**
+       * Read a .mmd file and parse it into a structured GraphModel.
+       */
+      async readGraph(filePath) {
+        const resolved = this.resolvePath(filePath);
+        const raw = await readFile(resolved, "utf-8");
+        return parseMermaidToGraph(raw, filePath);
+      }
+      /**
+       * Write a .mmd file. If flags or statuses are provided, injects annotation block.
+       * Creates parent directories if they don't exist.
+       */
+      async writeDiagram(filePath, content, flags, statuses, breakpoints, risks, ghosts) {
+        return this.withWriteLock(
+          filePath,
+          () => this._writeDiagramInternal(filePath, content, flags, statuses, breakpoints, risks, ghosts)
+        );
+      }
+      /**
+       * Write diagram content while preserving existing developer-owned annotations (flags, breakpoints).
+       * Reads existing annotations first, merges caller-provided statuses/risks/ghosts on top, preserves flags
+       * and breakpoints unconditionally, then writes the merged result atomically under the write lock.
+       *
+       * Merge semantics:
+       * - `content`: always replaces the Mermaid diagram body
+       * - `statuses`: if provided, replaces all statuses; if undefined, preserves existing
+       * - `risks`: if provided, replaces all risks; if undefined, preserves existing
+       * - `ghosts`: if provided, replaces all ghosts; if undefined, preserves existing
+       * - `flags`: always preserved from the file (developer-owned, never touched by MCP)
+       * - `breakpoints`: always preserved from the file (developer-owned, never touched by MCP)
+       */
+      async writeDiagramPreserving(filePath, content, statuses, risks, ghosts) {
+        return this.withWriteLock(filePath, async () => {
+          let existingFlags = /* @__PURE__ */ new Map();
+          let existingBreakpoints = /* @__PURE__ */ new Set();
+          let existingStatuses = /* @__PURE__ */ new Map();
+          let existingRisks = /* @__PURE__ */ new Map();
+          let existingGhosts = [];
+          try {
+            const data = await this.readAllAnnotations(filePath);
+            existingFlags = data.flags;
+            existingBreakpoints = data.breakpoints;
+            existingStatuses = data.statuses;
+            existingRisks = data.risks;
+            existingGhosts = data.ghosts;
+          } catch {
+          }
+          await this._writeDiagramInternal(
+            filePath,
+            content,
+            existingFlags,
+            // always preserve
+            statuses ?? existingStatuses,
+            // replace if provided, else preserve
+            existingBreakpoints,
+            // always preserve
+            risks ?? existingRisks,
+            // replace if provided, else preserve
+            ghosts ?? existingGhosts
+            // replace if provided, else preserve
+          );
+        });
+      }
+      /**
+       * Write raw content to a .mmd file under the write lock.
+       * Does NOT process annotations -- writes content as-is.
+       * Used by /save endpoint which receives pre-formatted content from the editor.
+       */
+      async writeRaw(filePath, content) {
+        return this.withWriteLock(filePath, async () => {
+          const resolved = this.resolvePath(filePath);
+          await mkdir(dirname2(resolved), { recursive: true });
+          await writeFile(resolved, content, "utf-8");
+        });
+      }
+      /**
+       * Internal write without acquiring the lock.
+       * Used by methods that already hold the write lock for the same file.
+       */
+      async _writeDiagramInternal(filePath, content, flags, statuses, breakpoints, risks, ghosts) {
+        const resolved = this.resolvePath(filePath);
+        let output = content;
+        if (flags || statuses || breakpoints || risks || ghosts && ghosts.length > 0) {
+          output = injectAnnotations(content, flags ?? /* @__PURE__ */ new Map(), statuses, breakpoints, risks, ghosts);
+        }
+        await mkdir(dirname2(resolved), { recursive: true });
+        await writeFile(resolved, output, "utf-8");
+      }
+      /** Get all flags from a .mmd file as an array. */
+      async getFlags(filePath) {
+        const diagram = await this.readDiagram(filePath);
+        return Array.from(diagram.flags.values());
+      }
+      /** Set (add or update) a flag on a specific node. */
+      async setFlag(filePath, nodeId, message) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.flags.set(nodeId, { nodeId, message });
+        });
+      }
+      /** Remove a flag from a specific node. */
+      async removeFlag(filePath, nodeId) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.flags.delete(nodeId);
+        });
+      }
+      /** Get all statuses from a .mmd file. */
+      async getStatuses(filePath) {
+        const diagram = await this.readDiagram(filePath);
+        return diagram.statuses;
+      }
+      /** Set (add or update) a status on a specific node. */
+      async setStatus(filePath, nodeId, status) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.statuses.set(nodeId, status);
+        });
+      }
+      /** Remove a status from a specific node. */
+      async removeStatus(filePath, nodeId) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.statuses.delete(nodeId);
+        });
+      }
+      /** Get all breakpoints from a .mmd file. */
+      async getBreakpoints(filePath) {
+        const resolved = this.resolvePath(filePath);
+        const raw = await readFile(resolved, "utf-8");
+        return parseAllAnnotations(raw).breakpoints;
+      }
+      /** Set (add) a breakpoint on a specific node. */
+      async setBreakpoint(filePath, nodeId) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.breakpoints.add(nodeId);
+        });
+      }
+      /** Remove a breakpoint from a specific node. */
+      async removeBreakpoint(filePath, nodeId) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.breakpoints.delete(nodeId);
+        });
+      }
+      /** Get all risk annotations from a .mmd file. */
+      async getRisks(filePath) {
+        const resolved = this.resolvePath(filePath);
+        const raw = await readFile(resolved, "utf-8");
+        return parseAllAnnotations(raw).risks;
+      }
+      /** Set (add or update) a risk annotation on a specific node. */
+      async setRisk(filePath, nodeId, level, reason) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.risks.set(nodeId, { nodeId, level, reason });
+        });
+      }
+      /** Remove a risk annotation from a specific node. */
+      async removeRisk(filePath, nodeId) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.risks.delete(nodeId);
+        });
+      }
+      /** Get all ghost path annotations from a .mmd file. */
+      async getGhosts(filePath) {
+        const resolved = this.resolvePath(filePath);
+        const raw = await readFile(resolved, "utf-8");
+        return parseAllAnnotations(raw).ghosts;
+      }
+      /** Add a ghost path annotation to a .mmd file. */
+      async addGhost(filePath, fromNodeId, toNodeId, label) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.ghosts.push({ fromNodeId, toNodeId, label });
+        });
+      }
+      /** Remove a specific ghost path annotation (by from+to+label exact match). */
+      async removeGhost(filePath, fromNodeId, toNodeId) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.ghosts = data.ghosts.filter(
+            (g) => !(g.fromNodeId === fromNodeId && g.toNodeId === toNodeId)
+          );
+        });
+      }
+      /** Clear all ghost path annotations from a .mmd file. */
+      async clearGhosts(filePath) {
+        return this.modifyAnnotation(filePath, (data) => {
+          data.ghosts = [];
+        });
+      }
+      /** Validate the Mermaid syntax of a .mmd file. */
+      async validate(filePath) {
+        const diagram = await this.readDiagram(filePath);
+        return diagram.validation;
+      }
+      /** List all .mmd files in the project root. */
+      async listFiles() {
+        return discoverMmdFiles(this.projectRoot);
+      }
+      /**
+       * Resolve a relative file path against the project root.
+       * Single chokepoint for path security -- rejects path traversal.
+       */
+      resolvePath(filePath) {
+        return resolveProjectPath(this.projectRoot, filePath);
+      }
+    };
+  }
+});
+
+// src/server/static.ts
+import { readFile as readFile2 } from "fs/promises";
+import { extname } from "path";
+async function serveStaticFile(res, filePath) {
+  try {
+    const content = await readFile2(filePath);
+    const ext = extname(filePath);
+    const mime = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": mime });
+    res.end(content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var MIME_TYPES;
+var init_static = __esm({
+  "src/server/static.ts"() {
+    "use strict";
+    MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".mmd": "text/plain; charset=utf-8"
+    };
+  }
+});
+
+// src/diagram/collapser-parser.ts
+function parseSubgraphs(content) {
+  const subgraphs = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  const stack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const startMatch = line.match(SUBGRAPH_START);
+    if (startMatch) {
+      const id = startMatch[1];
+      const label = startMatch[2] || id;
+      const parent = stack.length > 0 ? stack[stack.length - 1].id : null;
+      const info = {
+        id,
+        label,
+        startLine: i,
+        endLine: -1,
+        nodeIds: [],
+        childSubgraphs: [],
+        parent
+      };
+      stack.push(info);
+      if (parent) {
+        const parentInfo = subgraphs.get(parent) || stack.find((s) => s.id === parent);
+        if (parentInfo) parentInfo.childSubgraphs.push(id);
+      }
+      continue;
+    }
+    if (SUBGRAPH_END.test(line) && stack.length > 0) {
+      const completed = stack.pop();
+      completed.endLine = i;
+      subgraphs.set(completed.id, completed);
+      continue;
+    }
+    if (stack.length > 0) {
+      const current = stack[stack.length - 1];
+      const nodeMatch = line.match(NODE_DEF);
+      const edgeMatch = line.match(EDGE_LINE);
+      if (nodeMatch && !current.nodeIds.includes(nodeMatch[1])) {
+        current.nodeIds.push(nodeMatch[1]);
+      } else if (edgeMatch && !current.nodeIds.includes(edgeMatch[1])) {
+        current.nodeIds.push(edgeMatch[1]);
+      }
+    }
+  }
+  while (stack.length > 0) {
+    const incomplete = stack.pop();
+    incomplete.endLine = lines.length - 1;
+    subgraphs.set(incomplete.id, incomplete);
+  }
+  return subgraphs;
+}
+function countAllNodes(content) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const nodeMatch = line.match(NODE_DEF);
+    const edgeMatch = line.match(EDGE_LINE);
+    if (nodeMatch) seen.add(nodeMatch[1]);
+    if (edgeMatch) seen.add(edgeMatch[1]);
+  }
+  return seen.size;
+}
+function countNodesInSubgraph(info, subgraphs) {
+  let count = info.nodeIds.length;
+  for (const childId of info.childSubgraphs) {
+    const child = subgraphs.get(childId);
+    if (child) count += countNodesInSubgraph(child, subgraphs);
+  }
+  return count;
+}
+function countVisibleNodes(content, subgraphs, state) {
+  let total = countAllNodes(content);
+  for (const subgraphId of state.collapsed) {
+    const info = subgraphs.get(subgraphId);
+    if (!info) continue;
+    if (info.parent && state.collapsed.has(info.parent)) continue;
+    total -= countNodesInSubgraph(info, subgraphs);
+    total += 1;
+  }
+  return Math.max(0, total);
+}
+function getLeafSubgraphs(subgraphs) {
+  return [...subgraphs.values()].filter((s) => s.childSubgraphs.length === 0);
+}
+function getAllNodesInSubgraph(info, subgraphs) {
+  const nodes = [...info.nodeIds];
+  for (const childId of info.childSubgraphs) {
+    const child = subgraphs.get(childId);
+    if (child) nodes.push(...getAllNodesInSubgraph(child, subgraphs));
+  }
+  return nodes;
+}
+function findContainingSubgraph(nodeId, subgraphs) {
+  let deepest = null;
+  for (const info of subgraphs.values()) {
+    if (info.nodeIds.includes(nodeId)) {
+      if (!deepest || info.parent && info.parent === deepest.id) {
+        deepest = info;
+      }
+    }
+  }
+  return deepest?.id || null;
+}
+function getPathToRoot(subgraphId, subgraphs) {
+  const path6 = [];
+  let current = subgraphs.get(subgraphId);
+  while (current) {
+    path6.unshift(current.id);
+    current = current.parent ? subgraphs.get(current.parent) : void 0;
+  }
+  return path6;
+}
+var NODE_DEF, EDGE_LINE;
+var init_collapser_parser = __esm({
+  "src/diagram/collapser-parser.ts"() {
+    "use strict";
+    init_constants();
+    NODE_DEF = /^\s*(\w[\w\d_-]*)(?:\s*\[|\s*\(|\s*\{|\s*\[\[|\s*>)/;
+    EDGE_LINE = /^\s*(\w[\w\d_-]*)\s*(?:-->|---|-\.-|-.->|==>|-.->)/;
+  }
+});
+
+// src/diagram/collapser-transform.ts
+function createEmptyState() {
+  return {
+    collapsed: /* @__PURE__ */ new Set(),
+    focusPath: [],
+    focusedSubgraph: null
+  };
+}
+function autoCollapseToLimit(content, subgraphs, state, config) {
+  if (!config.autoCollapse) return state;
+  const newCollapsed = new Set(state.collapsed);
+  let visibleNodes = countVisibleNodes(content, subgraphs, { ...state, collapsed: newCollapsed });
+  while (visibleNodes > config.maxVisibleNodes) {
+    const leaves = getLeafSubgraphs(subgraphs).filter((s) => !newCollapsed.has(s.id)).sort((a, b) => countNodesInSubgraph(b, subgraphs) - countNodesInSubgraph(a, subgraphs));
+    if (leaves.length === 0) break;
+    const largest = leaves[0];
+    newCollapsed.add(largest.id);
+    visibleNodes = countVisibleNodes(content, subgraphs, { ...state, collapsed: newCollapsed });
+  }
+  return { ...state, collapsed: newCollapsed };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function generateCollapsedView(content, subgraphs, state, config = DEFAULT_CONFIG) {
+  const autoState = autoCollapseToLimit(content, subgraphs, state, config);
+  const autoCollapsed = [...autoState.collapsed].filter((id) => !state.collapsed.has(id));
+  const manualCollapsed = [...state.collapsed];
+  const lines = content.split("\n");
+  const result = [];
+  const edgeRedirects = /* @__PURE__ */ new Map();
+  const skipRanges = [];
+  for (const subgraphId of autoState.collapsed) {
+    const info = subgraphs.get(subgraphId);
+    if (!info) continue;
+    if (info.parent && autoState.collapsed.has(info.parent)) continue;
+    skipRanges.push({ start: info.startLine, end: info.endLine, id: subgraphId });
+    const summaryId = `${config.collapsedNodePrefix}${subgraphId}`;
+    for (const nodeId of getAllNodesInSubgraph(info, subgraphs)) {
+      edgeRedirects.set(nodeId, summaryId);
+    }
+  }
+  skipRanges.sort((a, b) => a.start - b.start);
+  const compiledRedirects = [];
+  for (const [from, to] of edgeRedirects) {
+    compiledRedirects.push({
+      regex: new RegExp(`\\b${escapeRegExp(from)}\\b`, "g"),
+      replacement: to
+    });
+  }
+  let skipIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (skipIndex < skipRanges.length && i >= skipRanges[skipIndex].start) {
+      if (i === skipRanges[skipIndex].start) {
+        const range = skipRanges[skipIndex];
+        const summaryId = `${config.collapsedNodePrefix}${range.id}`;
+        const info = subgraphs.get(range.id);
+        const nodeCount = countNodesInSubgraph(info, subgraphs);
+        result.push(`    ${summaryId}["[+]${info.label} (${nodeCount} nodes)"]`);
+      }
+      if (i <= skipRanges[skipIndex].end) {
+        if (i === skipRanges[skipIndex].end) skipIndex++;
+        continue;
+      }
+    }
+    let line = lines[i];
+    for (const { regex, replacement } of compiledRedirects) {
+      regex.lastIndex = 0;
+      line = line.replace(regex, replacement);
+    }
+    result.push(line);
+  }
+  const collapsedContent = result.join("\n");
+  const visibleNodes = countVisibleNodes(content, subgraphs, autoState);
+  return {
+    content: collapsedContent,
+    visibleNodes,
+    autoCollapsed,
+    manualCollapsed
+  };
+}
+function focusOnNode(nodeId, subgraphs, currentState) {
+  const containingSubgraph = findContainingSubgraph(nodeId, subgraphs);
+  if (!containingSubgraph) return currentState;
+  const focusPath = getPathToRoot(containingSubgraph, subgraphs);
+  const newCollapsed = /* @__PURE__ */ new Set();
+  for (const info of subgraphs.values()) {
+    if (!focusPath.includes(info.id)) {
+      if (info.parent == null || focusPath.includes(info.parent)) {
+        newCollapsed.add(info.id);
+      }
+    }
+  }
+  return {
+    collapsed: newCollapsed,
+    focusPath,
+    focusedSubgraph: containingSubgraph
+  };
+}
+function navigateToBreadcrumb(breadcrumbId, _subgraphs, currentState) {
+  if (breadcrumbId === "root") {
+    return exitFocus();
+  }
+  const index = currentState.focusPath.indexOf(breadcrumbId);
+  if (index === -1) return currentState;
+  const newFocusPath = currentState.focusPath.slice(0, index + 1);
+  const focusedSubgraph = newFocusPath[newFocusPath.length - 1] || null;
+  return {
+    ...currentState,
+    focusPath: newFocusPath,
+    focusedSubgraph
+  };
+}
+function exitFocus() {
+  return {
+    collapsed: /* @__PURE__ */ new Set(),
+    focusPath: [],
+    focusedSubgraph: null
+  };
+}
+function getBreadcrumbs(state, subgraphs) {
+  const crumbs = [{ id: "root", label: "Overview" }];
+  for (const id of state.focusPath) {
+    const info = subgraphs.get(id);
+    if (info) crumbs.push({ id, label: info.label });
+  }
+  return crumbs;
+}
+var DEFAULT_CONFIG;
+var init_collapser_transform = __esm({
+  "src/diagram/collapser-transform.ts"() {
+    "use strict";
+    init_collapser_parser();
+    DEFAULT_CONFIG = {
+      collapsedNodePrefix: "__collapsed__",
+      maxVisibleNodes: 50,
+      autoCollapse: true
+    };
+  }
+});
+
+// src/diagram/collapser.ts
+var init_collapser = __esm({
+  "src/diagram/collapser.ts"() {
+    "use strict";
+    init_collapser_parser();
+    init_collapser_transform();
+  }
+});
+
+// src/diagram/graph-serializer.ts
+function serializeGraphModel(graph) {
+  return {
+    diagramType: graph.diagramType,
+    direction: graph.direction,
+    nodes: Object.fromEntries(graph.nodes),
+    edges: graph.edges,
+    subgraphs: Object.fromEntries(graph.subgraphs),
+    classDefs: Object.fromEntries(graph.classDefs),
+    nodeStyles: Object.fromEntries(graph.nodeStyles),
+    linkStyles: Object.fromEntries(graph.linkStyles),
+    classAssignments: Object.fromEntries(graph.classAssignments),
+    filePath: graph.filePath,
+    flags: Object.fromEntries(graph.flags),
+    statuses: Object.fromEntries(graph.statuses)
+  };
+}
+var SHAPE_BRACKETS;
+var init_graph_serializer = __esm({
+  "src/diagram/graph-serializer.ts"() {
+    "use strict";
+    init_graph_types();
+    SHAPE_BRACKETS = /* @__PURE__ */ new Map();
+    for (const sp of SHAPE_PATTERNS) {
+      if (!SHAPE_BRACKETS.has(sp.shape)) {
+        SHAPE_BRACKETS.set(sp.shape, { open: sp.open, close: sp.close });
+      }
+    }
+  }
+});
+
+// src/server/session-routes.ts
+function registerSessionRoutes(routes, sessionStore) {
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/sessions/(?<file>.+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const sessionIds = await sessionStore.listSessions(file);
+        const sessions = await Promise.all(
+          sessionIds.map(async (sessionId) => {
+            try {
+              const events = await sessionStore.readSession(sessionId);
+              const startEvent = events.find((e) => e.type === "session:start");
+              const endEvent = events.find((e) => e.type === "session:end");
+              const startTs = startEvent?.ts ?? 0;
+              const endTs = endEvent?.ts ?? (events.length > 0 ? events[events.length - 1].ts : 0);
+              return {
+                sessionId,
+                totalEvents: events.length,
+                duration: endTs - startTs,
+                startedAt: startTs
+              };
+            } catch {
+              return { sessionId, totalEvents: 0, duration: 0, startedAt: 0 };
+            }
+          })
+        );
+        sendJson(res, { sessions });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/session/(?<id>[^/]+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const id = decodeURIComponent(params["id"]);
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
+          sendJson(res, { error: "Invalid session ID" }, 400);
+          return;
+        }
+        const events = await sessionStore.readSession(id);
+        if (events.length === 0) {
+          sendJson(res, { error: "Session not found" }, 404);
+          return;
+        }
+        sendJson(res, { events });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+}
+var init_session_routes = __esm({
+  "src/server/session-routes.ts"() {
+    "use strict";
+    init_server();
+  }
+});
+
+// src/server/file-tree.ts
+function buildFileTree(files) {
+  const root = [];
+  for (const filePath of files) {
+    const parts = filePath.split("/");
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isFile = i === parts.length - 1;
+      if (isFile) {
+        current.push({ type: "file", name: part, path: filePath });
+      } else {
+        let folder = current.find(
+          (n) => n.type === "folder" && n.name === part
+        );
+        if (!folder) {
+          folder = { type: "folder", name: part, children: [] };
+          current.push(folder);
+        }
+        current = folder.children;
+      }
+    }
+  }
+  return root;
+}
+var init_file_tree = __esm({
+  "src/server/file-tree.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/file-routes.ts
+import { mkdir as mkdir2, unlink, rename, rm } from "fs/promises";
+import path2 from "path";
+function registerFileRoutes(routes, service, projectDir) {
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/tree\\.json$"),
+    handler: async (_req, res) => {
+      try {
+        const files = await service.listFiles();
+        const tree = buildFileTree(files);
+        sendJson(res, tree);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/save$"),
+    handler: async (req, res) => {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.filename || body.content === void 0) {
+          sendJson(res, { error: "Missing filename or content" }, 400);
+          return;
+        }
+        await service.writeRaw(body.filename, body.content);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/delete$"),
+    handler: async (req, res) => {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.filename) {
+          sendJson(res, { error: "Missing filename" }, 400);
+          return;
+        }
+        const resolved = resolveProjectPath(projectDir, body.filename);
+        await unlink(resolved);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/mkdir$"),
+    handler: async (req, res) => {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.folder) {
+          sendJson(res, { error: "Missing folder" }, 400);
+          return;
+        }
+        const resolved = resolveProjectPath(projectDir, body.folder);
+        await mkdir2(resolved, { recursive: true });
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/move$"),
+    handler: async (req, res) => {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.from || !body.to) {
+          sendJson(res, { error: "Missing from or to" }, 400);
+          return;
+        }
+        const resolvedFrom = resolveProjectPath(projectDir, body.from);
+        const resolvedTo = resolveProjectPath(projectDir, body.to);
+        await mkdir2(path2.dirname(resolvedTo), { recursive: true });
+        await rename(resolvedFrom, resolvedTo);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/rmdir$"),
+    handler: async (req, res) => {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.folder) {
+          sendJson(res, { error: "Missing folder" }, 400);
+          return;
+        }
+        const resolved = resolveProjectPath(projectDir, body.folder);
+        await rm(resolved, { recursive: true });
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+}
+var init_file_routes = __esm({
+  "src/server/file-routes.ts"() {
+    "use strict";
+    init_paths();
+    init_server();
+    init_file_tree();
+  }
+});
+
+// src/server/breakpoint-routes.ts
+function registerBreakpointRoutes(routes, service, wsManager, breakpointContinueSignals) {
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/api/breakpoints/(?<file>.+)/continue$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const body = await readJsonBody(req);
+        if (!body.nodeId) {
+          sendJson(res, { error: "Missing nodeId" }, 400);
+          return;
+        }
+        if (breakpointContinueSignals) {
+          if (breakpointContinueSignals.size >= 500) {
+            const firstKey = breakpointContinueSignals.keys().next().value;
+            if (firstKey !== void 0) breakpointContinueSignals.delete(firstKey);
+          }
+          breakpointContinueSignals.set(`${file}:${body.nodeId}`, true);
+        }
+        if (wsManager) {
+          wsManager.broadcastAll({ type: "breakpoint:continue", file, nodeId: body.nodeId });
+        }
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/breakpoints/(?<file>.+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const breakpoints = await service.getBreakpoints(file);
+        sendJson(res, { breakpoints: Array.from(breakpoints) });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/api/breakpoints/(?<file>.+)$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const body = await readJsonBody(req);
+        if (!body.nodeId || !body.action) {
+          sendJson(res, { error: "Missing nodeId or action" }, 400);
+          return;
+        }
+        if (body.action === "set") {
+          await service.setBreakpoint(file, body.nodeId);
+          if (wsManager) {
+            wsManager.broadcastAll({ type: "breakpoint:hit", file, nodeId: body.nodeId });
+          }
+        } else {
+          await service.removeBreakpoint(file, body.nodeId);
+        }
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+}
+var init_breakpoint_routes = __esm({
+  "src/server/breakpoint-routes.ts"() {
+    "use strict";
+    init_server();
+  }
+});
+
+// src/server/ghost-path-routes.ts
+function registerGhostPathRoutes(routes, service, wsManager) {
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/ghost-paths/(?<file>.+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const ghosts = await service.getGhosts(file);
+        sendJson(res, { ghostPaths: ghosts });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/api/ghost-paths/(?<file>.+)$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const body = await readJsonBody(req);
+        if (!body.fromNodeId || !body.toNodeId) {
+          sendJson(res, { error: "Missing fromNodeId or toNodeId" }, 400);
+          return;
+        }
+        await service.addGhost(file, body.fromNodeId, body.toNodeId, body.label ?? "");
+        const ghostPaths = await service.getGhosts(file);
+        if (wsManager) {
+          wsManager.broadcastAll({ type: "ghost:update", file, ghostPaths });
+        }
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "DELETE",
+    pattern: new RegExp("^/api/ghost-paths/(?<file>.+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        await service.clearGhosts(file);
+        if (wsManager) {
+          wsManager.broadcastAll({ type: "ghost:update", file, ghostPaths: [] });
+        }
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+}
+var init_ghost_path_routes = __esm({
+  "src/server/ghost-path-routes.ts"() {
+    "use strict";
+    init_server();
+  }
+});
+
+// src/server/annotation-routes.ts
+function registerAnnotationRoutes(routes, service) {
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/annotations/(?<file>.+)/risks$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const risks = await service.getRisks(file);
+        const entries = [];
+        for (const [, risk] of risks) {
+          entries.push({ nodeId: risk.nodeId, level: risk.level, reason: risk.reason });
+        }
+        sendJson(res, { risks: entries });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/api/annotations/(?<file>.+)/risk$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const body = await readJsonBody(req);
+        if (!body.nodeId || !body.level || !body.reason) {
+          sendJson(res, { error: "Missing nodeId, level, or reason" }, 400);
+          return;
+        }
+        if (!VALID_RISK_LEVELS.has(body.level)) {
+          sendJson(res, { error: `Invalid level: must be high, medium, or low` }, 400);
+          return;
+        }
+        await service.setRisk(file, body.nodeId, body.level, body.reason);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "DELETE",
+    pattern: new RegExp("^/api/annotations/(?<file>.+)/risk$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const body = await readJsonBody(req);
+        if (!body.nodeId) {
+          sendJson(res, { error: "Missing nodeId" }, 400);
+          return;
+        }
+        await service.removeRisk(file, body.nodeId);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Payload too large") {
+          sendJson(res, { error: message }, 413);
+          return;
+        }
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+}
+var VALID_RISK_LEVELS;
+var init_annotation_routes = __esm({
+  "src/server/annotation-routes.ts"() {
+    "use strict";
+    init_server();
+    VALID_RISK_LEVELS = /* @__PURE__ */ new Set(["high", "medium", "low"]);
+  }
+});
+
+// src/registry/mcp-session-registry.ts
+import { readFile as readFile3, writeFile as writeFile2, readdir as readdir2, mkdir as mkdir3, rename as rename2, unlink as unlink2 } from "fs/promises";
+import { join as join3 } from "path";
+import { tmpdir } from "os";
+import { randomBytes, randomUUID } from "crypto";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var McpSessionRegistry;
+var init_mcp_session_registry = __esm({
+  "src/registry/mcp-session-registry.ts"() {
+    "use strict";
+    init_logger();
+    McpSessionRegistry = class _McpSessionRegistry {
+      manifestDir;
+      projectRoot;
+      sessions = /* @__PURE__ */ new Map();
+      activeSessionId = null;
+      constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.manifestDir = join3(projectRoot, ".smartcode", "mcp-sessions");
+      }
+      /** Register the registry by ensuring the manifest directory exists */
+      async register() {
+        await mkdir3(this.manifestDir, { recursive: true });
+        if (this.sessions.size === 0) {
+          await this.createSession();
+        }
+        log.debug(`MCP session registry registered (pid ${process.pid})`);
+      }
+      /**
+       * Create a new session and make it the active one.
+       * Returns the new session ID.
+       */
+      async createSession(label) {
+        await mkdir3(this.manifestDir, { recursive: true });
+        const sessionId = randomUUID();
+        const shortId = sessionId.substring(0, 8);
+        const session = {
+          sessionId,
+          label: label || `Session ${shortId}`,
+          startedAt: Date.now(),
+          diagrams: /* @__PURE__ */ new Map()
+        };
+        this.sessions.set(sessionId, session);
+        this.activeSessionId = sessionId;
+        await this.writeManifest(session);
+        log.debug(`MCP session created: ${sessionId} (label: ${session.label})`);
+        return sessionId;
+      }
+      /** Switch the active session to an existing session ID */
+      setActiveSession(sessionId) {
+        if (!this.sessions.has(sessionId)) {
+          throw new Error(`Session not found: ${sessionId}`);
+        }
+        this.activeSessionId = sessionId;
+      }
+      /** Get the current active session ID (or null) */
+      getActiveSessionId() {
+        return this.activeSessionId;
+      }
+      /** Rename a session's label and persist to disk */
+      async renameSession(sessionId, label) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+          session.label = label;
+          await this.writeManifest(session);
+        }
+        await _McpSessionRegistry.renameOnDisk(this.projectRoot, sessionId, label);
+      }
+      /**
+       * Track a diagram file in the active session.
+       * Backward-compat: auto-creates a default session if none exists.
+       */
+      async trackDiagram(filePath) {
+        if (!this.activeSessionId || !this.sessions.has(this.activeSessionId)) {
+          await this.createSession();
+        }
+        const session = this.sessions.get(this.activeSessionId);
+        const now = Date.now();
+        const existing = session.diagrams.get(filePath);
+        if (existing) {
+          existing.lastUpdated = now;
+        } else {
+          session.diagrams.set(filePath, { filePath, firstSeen: now, lastUpdated: now });
+          if (session.label.startsWith("Session ")) {
+            const base = filePath.includes("/") ? filePath.split("/").pop() : filePath;
+            session.label = base.replace(".mmd", "");
+          }
+        }
+        await this.writeManifest(session);
+      }
+      /** Deregister all sessions owned by this process */
+      async deregister() {
+        for (const session of this.sessions.values()) {
+          try {
+            await unlink2(this.manifestPath(session.sessionId));
+          } catch {
+          }
+        }
+        this.sessions.clear();
+        this.activeSessionId = null;
+        log.debug(`MCP session registry deregistered (pid ${process.pid})`);
+      }
+      /** List all sessions owned by this process instance */
+      listSessions() {
+        return Array.from(this.sessions.values()).map((s) => this.buildManifest(s));
+      }
+      // ── Backward-compat getters ──
+      /** Get the session ID (returns active session for backward compat) */
+      get sessionId() {
+        return this.activeSessionId ?? "";
+      }
+      // ── Static methods (read from disk, cross-process) ──
+      /** List all active MCP sessions for a project (filters out dead PIDs, cleans stale) */
+      static async listActive(projectRoot) {
+        const dir = join3(projectRoot, ".smartcode", "mcp-sessions");
+        let entries;
+        try {
+          entries = await readdir2(dir);
+        } catch {
+          return [];
+        }
+        const manifests = [];
+        const stale = [];
+        for (const entry of entries) {
+          if (!entry.endsWith(".json")) continue;
+          try {
+            const raw = await readFile3(join3(dir, entry), "utf-8");
+            const manifest = JSON.parse(raw);
+            if (isProcessAlive(manifest.pid)) {
+              manifests.push(manifest);
+            } else {
+              stale.push(entry);
+            }
+          } catch {
+            stale.push(entry);
+          }
+        }
+        for (const s of stale) {
+          unlink2(join3(dir, s)).catch(() => {
+          });
+        }
+        return manifests;
+      }
+      /** Get a specific session manifest by ID */
+      static async getSession(projectRoot, sessionId) {
+        const filePath = join3(projectRoot, ".smartcode", "mcp-sessions", `${sessionId}.json`);
+        try {
+          const raw = await readFile3(filePath, "utf-8");
+          const manifest = JSON.parse(raw);
+          return isProcessAlive(manifest.pid) ? manifest : null;
+        } catch {
+          return null;
+        }
+      }
+      /** Rename a session on disk (works for any process's sessions) */
+      static async renameOnDisk(projectRoot, sessionId, label) {
+        const filePath = join3(projectRoot, ".smartcode", "mcp-sessions", `${sessionId}.json`);
+        try {
+          const raw = await readFile3(filePath, "utf-8");
+          const manifest = JSON.parse(raw);
+          manifest.label = label;
+          const data = JSON.stringify(manifest, null, 2);
+          const tempPath = join3(tmpdir(), `smartcode-mcp-${randomBytes(4).toString("hex")}.json`);
+          await writeFile2(tempPath, data, "utf-8");
+          try {
+            await rename2(tempPath, filePath);
+          } catch {
+            await writeFile2(filePath, data, "utf-8");
+            await unlink2(tempPath).catch(() => {
+            });
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      // ── Private helpers ──
+      manifestPath(sessionId) {
+        return join3(this.manifestDir, `${sessionId}.json`);
+      }
+      buildManifest(session) {
+        return {
+          sessionId: session.sessionId,
+          pid: process.pid,
+          startedAt: session.startedAt,
+          label: session.label,
+          diagrams: Array.from(session.diagrams.values())
+        };
+      }
+      /** Atomically write manifest (temp file + rename) */
+      async writeManifest(session) {
+        const data = JSON.stringify(this.buildManifest(session), null, 2);
+        const tempPath = join3(tmpdir(), `smartcode-mcp-${randomBytes(4).toString("hex")}.json`);
+        await writeFile2(tempPath, data, "utf-8");
+        try {
+          await rename2(tempPath, this.manifestPath(session.sessionId));
+        } catch {
+          await writeFile2(this.manifestPath(session.sessionId), data, "utf-8");
+          await unlink2(tempPath).catch(() => {
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/server/mcp-session-routes.ts
+function registerMcpSessionRoutes(routes, projectDir, wsManager) {
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/mcp-sessions$"),
+    handler: async (_req, res) => {
+      try {
+        const sessions = await McpSessionRegistry.listActive(projectDir);
+        sendJson(res, { sessions });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/mcp-sessions/(?<id>[^/]+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const id = decodeURIComponent(params["id"]);
+        const session = await McpSessionRegistry.getSession(projectDir, id);
+        if (!session) {
+          sendJson(res, { error: "Session not found" }, 404);
+          return;
+        }
+        sendJson(res, session);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "PATCH",
+    pattern: new RegExp("^/api/mcp-sessions/(?<id>[^/]+)$"),
+    handler: async (req, res, params) => {
+      try {
+        const id = decodeURIComponent(params["id"]);
+        const body = await readJsonBody(req);
+        const label = body?.label;
+        if (!label || typeof label !== "string" || !label.trim()) {
+          sendJson(res, { error: "label is required" }, 400);
+          return;
+        }
+        const ok = await McpSessionRegistry.renameOnDisk(projectDir, id, label.trim());
+        if (!ok) {
+          sendJson(res, { error: "Session not found" }, 404);
+          return;
+        }
+        if (wsManager) {
+          wsManager.broadcastAll({ type: "mcp-session:updated" });
+        }
+        sendJson(res, { ok: true, sessionId: id, label: label.trim() });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+}
+var init_mcp_session_routes = __esm({
+  "src/server/mcp-session-routes.ts"() {
+    "use strict";
+    init_mcp_session_registry();
+    init_server();
+  }
+});
+
+// src/server/heatmap-routes.ts
+function mergeCounts(a, b) {
+  const result = { ...a };
+  for (const [key, value] of Object.entries(b)) {
+    result[key] = (result[key] ?? 0) + value;
+  }
+  return result;
+}
+function registerHeatmapRoutes(routes, heatmapStore, sessionStore, wsManager) {
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/heatmap/(?<file>.+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const clickCounts = heatmapStore.getCounts(file);
+        let sessionCounts = {};
+        if (sessionStore) {
+          try {
+            sessionCounts = await sessionStore.getHeatmapData(file);
+          } catch {
+          }
+        }
+        const merged = mergeCounts(clickCounts, sessionCounts);
+        sendJson(res, merged);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "POST",
+    pattern: new RegExp("^/api/heatmap/(?<file>.+)/increment$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const body = await readJsonBody(req);
+        if (!body.counts || typeof body.counts !== "object") {
+          sendJson(res, { error: 'Missing or invalid "counts" field' }, 400);
+          return;
+        }
+        for (const [key, value] of Object.entries(body.counts)) {
+          if (typeof key !== "string" || typeof value !== "number" || value < 0) {
+            sendJson(res, { error: "Invalid count entry" }, 400);
+            return;
+          }
+        }
+        heatmapStore.increment(file, body.counts);
+        if (wsManager) {
+          const allCounts = heatmapStore.getCounts(file);
+          let sessionCounts = {};
+          if (sessionStore) {
+            try {
+              sessionCounts = await sessionStore.getHeatmapData(file);
+            } catch {
+            }
+          }
+          const merged = mergeCounts(allCounts, sessionCounts);
+          wsManager.broadcastAll({
+            type: "heatmap:update",
+            file,
+            data: merged
+          });
+        }
+        sendJson(res, { ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        if (message === "Invalid JSON" || message === "Payload too large") {
+          sendJson(res, { error: message }, 400);
+          return;
+        }
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+}
+var HeatmapStore;
+var init_heatmap_routes = __esm({
+  "src/server/heatmap-routes.ts"() {
+    "use strict";
+    init_server();
+    HeatmapStore = class {
+      data = /* @__PURE__ */ new Map();
+      /** Merge incoming counts into the store for a given file */
+      increment(file, counts) {
+        let fileMap = this.data.get(file);
+        if (!fileMap) {
+          fileMap = /* @__PURE__ */ new Map();
+          this.data.set(file, fileMap);
+        }
+        for (const [nodeId, count] of Object.entries(counts)) {
+          if (typeof count !== "number" || count < 0) continue;
+          fileMap.set(nodeId, (fileMap.get(nodeId) ?? 0) + count);
+        }
+      }
+      /** Get click counts for a file as a plain object */
+      getCounts(file) {
+        const fileMap = this.data.get(file);
+        if (!fileMap) return {};
+        const result = {};
+        for (const [nodeId, count] of fileMap) {
+          result[nodeId] = count;
+        }
+        return result;
+      }
+      /** Clear counts for a specific file (used in testing) */
+      clear(file) {
+        this.data.delete(file);
+      }
+      /** Clear all data (used in testing) */
+      clearAll() {
+        this.data.clear();
+      }
+    };
+  }
+});
+
+// src/registry/workspace-registry.ts
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4, rename as rename3, unlink as unlink3 } from "fs/promises";
+import { join as join4, basename } from "path";
+import { homedir, tmpdir as tmpdir2 } from "os";
+import { randomBytes as randomBytes2 } from "crypto";
+async function readRegistry() {
+  try {
+    const raw = await readFile4(REGISTRY_PATH, "utf-8");
+    const data = JSON.parse(raw);
+    return Array.isArray(data) ? data : [];
+  } catch {
+    return [];
+  }
+}
+async function writeRegistry(entries) {
+  await mkdir4(SMARTCODE_DIR, { recursive: true });
+  const tempPath = join4(tmpdir2(), `smartcode-registry-${randomBytes2(4).toString("hex")}.json`);
+  await writeFile3(tempPath, JSON.stringify(entries, null, 2), "utf-8");
+  try {
+    await rename3(tempPath, REGISTRY_PATH);
+  } catch {
+    await writeFile3(REGISTRY_PATH, JSON.stringify(entries, null, 2), "utf-8");
+    await unlink3(tempPath).catch(() => {
+    });
+  }
+}
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function filterAlive(entries) {
+  return entries.filter((e) => isProcessAlive2(e.pid));
+}
+async function register(dir, port) {
+  const name = basename(dir) || dir;
+  const pid = process.pid;
+  const entries = filterAlive(await readRegistry());
+  const cleaned = entries.filter((e) => e.port !== port && e.dir !== dir);
+  cleaned.push({ name, dir, port, pid });
+  await writeRegistry(cleaned);
+  log.debug(`Workspace registered: ${name} (port ${port}, pid ${pid})`);
+}
+async function deregister(port) {
+  const entries = await readRegistry();
+  const filtered = entries.filter((e) => e.port !== port);
+  await writeRegistry(filtered);
+  log.debug(`Workspace deregistered (port ${port})`);
+}
+async function list() {
+  const entries = await readRegistry();
+  const alive = filterAlive(entries);
+  if (alive.length !== entries.length) {
+    await writeRegistry(alive).catch(() => {
+    });
+  }
+  return alive;
+}
+var SMARTCODE_DIR, REGISTRY_PATH;
+var init_workspace_registry = __esm({
+  "src/registry/workspace-registry.ts"() {
+    "use strict";
+    init_logger();
+    SMARTCODE_DIR = join4(homedir(), ".smartcode");
+    REGISTRY_PATH = join4(SMARTCODE_DIR, "workspaces.json");
+  }
+});
+
+// src/server/routes.ts
+import { readFile as readFile5 } from "fs/promises";
+function registerRoutes(service, projectDir, wsManager, breakpointContinueSignals, sessionStore, heatmapStore) {
+  const routes = [];
+  registerFileRoutes(routes, service, projectDir);
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/status$"),
+    handler: async (_req, res) => {
+      try {
+        const files = await service.listFiles();
+        const activeFlags = [];
+        for (const file of files) {
+          try {
+            const flags = await service.getFlags(file);
+            for (const flag of flags) {
+              activeFlags.push({ file, nodeId: flag.nodeId, message: flag.message });
+            }
+          } catch {
+          }
+        }
+        sendJson(res, {
+          status: "running",
+          uptime: process.uptime(),
+          port: null,
+          projectDir,
+          files: files.length,
+          connectedClients: wsManager?.getClientCount() ?? 0,
+          activeFlags
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/diagrams$"),
+    handler: async (_req, res) => {
+      try {
+        const files = await service.listFiles();
+        sendJson(res, { files });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/diagrams/(?<file>.+)$"),
+    handler: async (req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const diagram = await service.readDiagram(file);
+        const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+        const collapsedParam = url.searchParams.get("collapsed");
+        const configParam = url.searchParams.get("collapseConfig");
+        const focusParam = url.searchParams.get("focus");
+        const breadcrumbParam = url.searchParams.get("breadcrumb");
+        let collapseConfig = { ...DEFAULT_CONFIG };
+        if (configParam) {
+          try {
+            const userConfig = JSON.parse(configParam);
+            collapseConfig = { ...DEFAULT_CONFIG, ...userConfig };
+          } catch {
+          }
+        }
+        const subgraphs = parseSubgraphs(diagram.mermaidContent);
+        let userCollapsed = [];
+        if (collapsedParam) {
+          try {
+            const parsed = JSON.parse(collapsedParam);
+            if (Array.isArray(parsed)) userCollapsed = parsed;
+          } catch {
+          }
+        }
+        let state = {
+          ...createEmptyState(),
+          collapsed: new Set(userCollapsed)
+        };
+        if (focusParam) {
+          state = focusOnNode(focusParam, subgraphs, state);
+        } else if (breadcrumbParam) {
+          state = navigateToBreadcrumb(breadcrumbParam, subgraphs, state);
+        }
+        const result = generateCollapsedView(
+          diagram.mermaidContent,
+          subgraphs,
+          state,
+          collapseConfig
+        );
+        const breadcrumbs = getBreadcrumbs(state, subgraphs);
+        sendJson(res, {
+          filePath: diagram.filePath,
+          mermaidContent: result.content,
+          rawContent: diagram.mermaidContent,
+          flags: Object.fromEntries(diagram.flags),
+          validation: {
+            valid: diagram.validation.valid,
+            errors: diagram.validation.errors,
+            diagramType: diagram.validation.diagramType
+          },
+          collapse: {
+            visibleNodes: result.visibleNodes,
+            autoCollapsed: result.autoCollapsed,
+            manualCollapsed: result.manualCollapsed,
+            config: collapseConfig,
+            breadcrumbs,
+            focusedSubgraph: state.focusedSubgraph
+          }
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/graph/(?<file>.+)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const file = decodeURIComponent(params["file"]);
+        const graph = await service.readGraph(file);
+        const json = serializeGraphModel(graph);
+        sendJson(res, json);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  registerBreakpointRoutes(routes, service, wsManager, breakpointContinueSignals);
+  registerGhostPathRoutes(routes, service, wsManager);
+  registerAnnotationRoutes(routes, service);
+  if (sessionStore) {
+    registerSessionRoutes(routes, sessionStore);
+  }
+  if (heatmapStore) {
+    registerHeatmapRoutes(routes, heatmapStore, sessionStore, wsManager);
+  }
+  registerMcpSessionRoutes(routes, projectDir, wsManager);
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/api/workspaces$"),
+    handler: async (_req, res) => {
+      try {
+        const workspaces = await list();
+        sendJson(res, workspaces);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        sendJson(res, { error: message }, 500);
+      }
+    }
+  });
+  routes.push({
+    method: "GET",
+    pattern: new RegExp("^/(?<mmdPath>.+\\.mmd)$"),
+    handler: async (_req, res, params) => {
+      try {
+        const filePath = params["mmdPath"];
+        const resolved = resolveProjectPath(projectDir, filePath);
+        const content = await readFile5(resolved, "utf-8");
+        res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end(content);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err?.code;
+        sendJson(res, { error: message }, code === "ENOENT" ? 404 : 500);
+      }
+    }
+  });
+  return routes;
+}
+var init_routes = __esm({
+  "src/server/routes.ts"() {
+    "use strict";
+    init_paths();
+    init_server();
+    init_collapser();
+    init_graph_serializer();
+    init_session_routes();
+    init_file_routes();
+    init_breakpoint_routes();
+    init_ghost_path_routes();
+    init_annotation_routes();
+    init_mcp_session_routes();
+    init_heatmap_routes();
+    init_workspace_registry();
+  }
+});
+
+// src/server/websocket.ts
+import { WebSocketServer, WebSocket as WsWebSocket } from "ws";
+var WebSocketManager;
+var init_websocket = __esm({
+  "src/server/websocket.ts"() {
+    "use strict";
+    init_logger();
+    WebSocketManager = class {
+      namespaces = /* @__PURE__ */ new Map();
+      constructor(httpServer) {
+        httpServer.on("upgrade", (request2, socket, head) => {
+          const { pathname } = new URL(request2.url, `http://${request2.headers.host}`);
+          let projectName = "default";
+          if (pathname.startsWith("/ws/")) {
+            projectName = decodeURIComponent(pathname.slice(4)) || "default";
+          } else if (pathname !== "/ws") {
+            socket.destroy();
+            return;
+          }
+          const wss = this.getOrCreateNamespace(projectName);
+          wss.handleUpgrade(request2, socket, head, (ws) => {
+            wss.emit("connection", ws, request2);
+          });
+        });
+      }
+      /** Get or create a WebSocketServer for the given project namespace */
+      getOrCreateNamespace(name) {
+        let wss = this.namespaces.get(name);
+        if (wss) return wss;
+        wss = new WebSocketServer({ noServer: true });
+        wss.on("connection", (ws) => {
+          ws.on("error", (err) => log.error(`WebSocket error [${name}]:`, err.message));
+          ws.send(JSON.stringify({ type: "connected", project: name }));
+        });
+        this.namespaces.set(name, wss);
+        return wss;
+      }
+      /** Ensure a namespace exists for the given project name */
+      addProject(name) {
+        this.getOrCreateNamespace(name);
+      }
+      /** Broadcast a JSON message to all clients in a specific project namespace */
+      broadcast(projectName, message) {
+        const wss = this.namespaces.get(projectName);
+        if (!wss) return;
+        const data = JSON.stringify(message);
+        wss.clients.forEach((client) => {
+          if (client.readyState === WsWebSocket.OPEN) {
+            client.send(data);
+          }
+        });
+      }
+      /** Broadcast a JSON message to all clients across all namespaces */
+      broadcastAll(message) {
+        const data = JSON.stringify(message);
+        for (const wss of this.namespaces.values()) {
+          wss.clients.forEach((client) => {
+            if (client.readyState === WsWebSocket.OPEN) {
+              client.send(data);
+            }
+          });
+        }
+      }
+      /** Count connected clients with OPEN readyState */
+      getClientCount(namespace) {
+        if (namespace) {
+          const wss = this.namespaces.get(namespace);
+          if (!wss) return 0;
+          let count = 0;
+          wss.clients.forEach((client) => {
+            if (client.readyState === WsWebSocket.OPEN) count++;
+          });
+          return count;
+        }
+        let total = 0;
+        for (const wss of this.namespaces.values()) {
+          wss.clients.forEach((client) => {
+            if (client.readyState === WsWebSocket.OPEN) total++;
+          });
+        }
+        return total;
+      }
+      /** Close all WebSocketServer instances */
+      close() {
+        for (const wss of this.namespaces.values()) {
+          wss.close();
+        }
+        this.namespaces.clear();
+      }
+    };
+  }
+});
+
+// src/watcher/file-watcher.ts
+import { watch, existsSync as existsSync2 } from "fs";
+import path3 from "path";
+var FileWatcher;
+var init_file_watcher = __esm({
+  "src/watcher/file-watcher.ts"() {
+    "use strict";
+    init_discovery();
+    init_logger();
+    FileWatcher = class _FileWatcher {
+      constructor(projectDir, onFileChanged, onFileAdded, onFileRemoved) {
+        this.projectDir = projectDir;
+        this.onFileChanged = onFileChanged;
+        this.onFileAdded = onFileAdded;
+        this.onFileRemoved = onFileRemoved;
+        this.ready = discoverMmdFiles(projectDir).then((files) => {
+          for (const f of files) this.knownFiles.add(f);
+          log.debug(`FileWatcher pre-populated ${files.length} known files`);
+        }).catch(() => {
+          log.warn("FileWatcher: failed to discover existing files, first events may misclassify");
+        });
+        this.watcher = watch(
+          projectDir,
+          { recursive: true },
+          (_eventType, filename) => {
+            if (!filename) return;
+            const relative = filename.split(path3.sep).join("/");
+            if (!relative.endsWith(".mmd")) return;
+            if (relative.includes("node_modules/") || relative.includes(".git/")) return;
+            const existing = this.debounceTimers.get(relative);
+            if (existing) clearTimeout(existing);
+            this.debounceTimers.set(relative, setTimeout(() => {
+              this.debounceTimers.delete(relative);
+              this.ready.then(() => this.handleEvent(relative));
+            }, _FileWatcher.DEBOUNCE_MS));
+          }
+        );
+        log.debug(`FileWatcher started for ${projectDir} (native fs.watch recursive)`);
+      }
+      watcher;
+      /** Debounce map to avoid duplicate events for the same file */
+      debounceTimers = /* @__PURE__ */ new Map();
+      static DEBOUNCE_MS = 80;
+      /** Tracks known files so we can distinguish adds from changes */
+      knownFiles = /* @__PURE__ */ new Set();
+      /** Resolves when initial file discovery is complete */
+      ready;
+      /** Check if file exists and route to appropriate callback */
+      handleEvent(relative) {
+        const absolute = path3.join(this.projectDir, relative);
+        const exists = existsSync2(absolute);
+        if (exists) {
+          if (this.knownFiles.has(relative)) {
+            log.debug(`File changed: ${relative}`);
+            this.onFileChanged(relative);
+          } else {
+            log.debug(`File added: ${relative}`);
+            this.knownFiles.add(relative);
+            this.onFileAdded(relative);
+          }
+        } else {
+          log.debug(`File removed: ${relative}`);
+          this.knownFiles.delete(relative);
+          this.onFileRemoved(relative);
+        }
+      }
+      /** Wait for initial file discovery to complete. Useful for tests. */
+      whenReady() {
+        return this.ready;
+      }
+      /** Close the file watcher and release OS file handles */
+      async close() {
+        this.watcher.close();
+        for (const timer of this.debounceTimers.values()) {
+          clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        log.debug("FileWatcher closed");
+      }
+    };
+  }
+});
+
+// src/session/session-store.ts
+import { appendFile, readFile as readFile6, readdir as readdir3, mkdir as mkdir5, open as fsOpen } from "fs/promises";
+import { join as join5 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var SessionStore;
+var init_session_store = __esm({
+  "src/session/session-store.ts"() {
+    "use strict";
+    SessionStore = class _SessionStore {
+      sessionsDir;
+      activeSessions = /* @__PURE__ */ new Map();
+      writeLocks = /* @__PURE__ */ new Map();
+      constructor(projectRoot) {
+        this.sessionsDir = join5(projectRoot, ".smartcode", "sessions");
+      }
+      /** Valid session ID pattern (UUID format) */
+      static SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+      /** Validate a session ID to prevent path traversal */
+      validateSessionId(sessionId) {
+        if (!_SessionStore.SESSION_ID_RE.test(sessionId)) {
+          throw new Error(`Invalid session ID: ${sessionId}`);
+        }
+      }
+      /** Ensure the sessions directory exists */
+      async ensureDir() {
+        await mkdir5(this.sessionsDir, { recursive: true });
+      }
+      /** Serialize write operations on a given session to prevent JSONL corruption */
+      async withWriteLock(sessionId, fn) {
+        const prev = this.writeLocks.get(sessionId) ?? Promise.resolve();
+        const current = prev.then(fn, fn);
+        const settled = current.then(() => {
+        }, () => {
+        });
+        this.writeLocks.set(sessionId, settled);
+        const result = await current;
+        if (this.writeLocks.get(sessionId) === settled) {
+          this.writeLocks.delete(sessionId);
+        }
+        return result;
+      }
+      /** Get the file path for a session's JSONL file */
+      filePath(sessionId) {
+        this.validateSessionId(sessionId);
+        return join5(this.sessionsDir, `${sessionId}.jsonl`);
+      }
+      /**
+       * Start a new session for a diagram file.
+       * Creates the sessions directory if needed, generates a UUID, and writes the start event.
+       * Returns the session ID.
+       */
+      async startSession(diagramFile) {
+        await this.ensureDir();
+        const id = randomUUID2();
+        const startedAt = Date.now();
+        const meta = { id, diagramFile, startedAt };
+        this.activeSessions.set(id, meta);
+        const startEvent = {
+          ts: startedAt,
+          type: "session:start",
+          payload: { diagramFile }
+        };
+        await appendFile(this.filePath(id), JSON.stringify(startEvent) + "\n", "utf-8");
+        return id;
+      }
+      /**
+       * Record a step (event) in an active session.
+       * Uses a write lock to prevent concurrent JSONL corruption.
+       */
+      async recordStep(sessionId, event) {
+        return this.withWriteLock(sessionId, async () => {
+          await appendFile(this.filePath(sessionId), JSON.stringify(event) + "\n", "utf-8");
+        });
+      }
+      /**
+       * End an active session.
+       * Appends a session:end event, computes summary statistics, and removes from active sessions.
+       */
+      async endSession(sessionId) {
+        const meta = this.activeSessions.get(sessionId);
+        if (!meta) {
+          throw new Error(`Session ${sessionId} is not active`);
+        }
+        const diagramFile = meta.diagramFile;
+        const endEvent = {
+          ts: Date.now(),
+          type: "session:end",
+          payload: {}
+        };
+        await this.withWriteLock(sessionId, async () => {
+          await appendFile(this.filePath(sessionId), JSON.stringify(endEvent) + "\n", "utf-8");
+        });
+        const events = await this.readSession(sessionId);
+        this.activeSessions.delete(sessionId);
+        this.writeLocks.delete(sessionId);
+        return this.computeSummary(events, sessionId, diagramFile);
+      }
+      /**
+       * Read all events from a session's JSONL file.
+       * Each line is parsed as a JSON object. Empty lines are filtered.
+       */
+      async readSession(sessionId) {
+        try {
+          const content = await readFile6(this.filePath(sessionId), "utf-8");
+          return content.split("\n").filter((line) => line.trim() !== "").map((line) => JSON.parse(line));
+        } catch (err) {
+          if (err?.code === "ENOENT") {
+            return [];
+          }
+          throw err;
+        }
+      }
+      /**
+       * List session IDs for a specific diagram file.
+       * Reads the first line of each .jsonl file to check the diagramFile in the session:start payload.
+       */
+      async listSessions(diagramFile) {
+        await this.ensureDir();
+        let entries;
+        try {
+          entries = await readdir3(this.sessionsDir);
+        } catch {
+          return [];
+        }
+        const matching = [];
+        for (const entry of entries) {
+          if (!entry.endsWith(".jsonl")) continue;
+          const sessionId = entry.replace(".jsonl", "");
+          try {
+            const firstLine = await this.readFirstLine(join5(this.sessionsDir, entry));
+            if (!firstLine) continue;
+            const event = JSON.parse(firstLine);
+            if (event.type === "session:start" && event.payload.diagramFile === diagramFile) {
+              matching.push(sessionId);
+            }
+          } catch {
+          }
+        }
+        return matching;
+      }
+      /**
+       * Get heatmap data for a diagram file: counts of node:visited events by nodeId.
+       * Aggregates across all sessions for the given file.
+       */
+      async getHeatmapData(diagramFile) {
+        const sessionIds = await this.listSessions(diagramFile);
+        const counts = {};
+        for (const sessionId of sessionIds) {
+          const events = await this.readSession(sessionId);
+          for (const event of events) {
+            if (event.type === "node:visited" && typeof event.payload.nodeId === "string") {
+              const nodeId = event.payload.nodeId;
+              counts[nodeId] = (counts[nodeId] ?? 0) + 1;
+            }
+          }
+        }
+        return counts;
+      }
+      /** Read only the first line of a file without loading the entire file into memory */
+      async readFirstLine(filePath) {
+        const fh = await fsOpen(filePath, "r");
+        try {
+          const buf = Buffer.alloc(4096);
+          const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+          if (bytesRead === 0) return null;
+          const text = buf.toString("utf-8", 0, bytesRead);
+          const newlineIdx = text.indexOf("\n");
+          return newlineIdx === -1 ? text : text.substring(0, newlineIdx);
+        } finally {
+          await fh.close();
+        }
+      }
+      /** Get metadata for an active session, or undefined if not active */
+      getActiveSession(sessionId) {
+        return this.activeSessions.get(sessionId);
+      }
+      /** Compute summary statistics from a list of session events */
+      computeSummary(events, sessionId, diagramFile) {
+        const startEvent = events.find((e) => e.type === "session:start");
+        const endEvent = events.find((e) => e.type === "session:end");
+        const startTs = startEvent?.ts ?? 0;
+        const endTs = endEvent?.ts ?? Date.now();
+        const duration = endTs - startTs;
+        let nodesVisited = 0;
+        const uniqueNodes = /* @__PURE__ */ new Set();
+        let edgesTraversed = 0;
+        for (const event of events) {
+          if (event.type === "node:visited") {
+            nodesVisited++;
+            if (typeof event.payload.nodeId === "string") {
+              uniqueNodes.add(event.payload.nodeId);
+            }
+          } else if (event.type === "edge:traversed") {
+            edgesTraversed++;
+          }
+        }
+        return {
+          sessionId,
+          diagramFile,
+          duration,
+          totalEvents: events.length,
+          nodesVisited,
+          uniqueNodesVisited: uniqueNodes.size,
+          edgesTraversed
+        };
+      }
+    };
+  }
+});
+
+// src/server/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createHttpServer: () => createHttpServer,
+  readJsonBody: () => readJsonBody,
+  sendJson: () => sendJson,
+  startServer: () => startServer
+});
+import { createServer } from "http";
+import { readFile as readFile7 } from "fs/promises";
+import path4 from "path";
+import { detect } from "detect-port";
+import open from "open";
+function setCorsHeaders(req, res) {
+  const origin = req.headers.origin;
+  if (origin && LOCALHOST_PATTERNS.some((p) => p.test(origin))) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  }
+}
+function sendJson(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+async function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let aborted = false;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_SIZE) {
+        aborted = true;
+        req.destroy();
+        reject(new Error("Payload too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (aborted) return;
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", (err) => {
+      if (!aborted) reject(err);
+    });
+  });
+}
+function createHandler(routes, staticDir) {
+  return async (req, res) => {
+    try {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      setCorsHeaders(req, res);
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      for (const route of routes) {
+        if (req.method === route.method) {
+          const match = route.pattern.exec(url.pathname);
+          if (match) {
+            const params = match.groups ?? {};
+            await route.handler(req, res, params);
+            return;
+          }
+        }
+      }
+      if (url.pathname === "/" || url.pathname === "/index.html") {
+        const served = await serveStaticFile(res, path4.join(staticDir, "live.html"));
+        if (served) return;
+      }
+      const safePath = path4.normalize(url.pathname).replace(/^(\.\.[/\\])+/, "");
+      const staticFilePath = path4.join(staticDir, safePath);
+      if (staticFilePath === staticDir || staticFilePath.startsWith(staticDir + path4.sep)) {
+        const served = await serveStaticFile(res, staticFilePath);
+        if (served) return;
+      }
+      sendJson(res, { error: "Not Found" }, 404);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal Server Error";
+      log.error("Request error:", message);
+      sendJson(res, { error: message }, 500);
+    }
+  };
+}
+function createHttpServer(projectDir, existingService) {
+  const resolvedDir = path4.resolve(projectDir);
+  const service = existingService ?? new DiagramService(resolvedDir);
+  const staticDir = getStaticDir();
+  const httpServer = createServer();
+  const wsManager = new WebSocketManager(httpServer);
+  const breakpointContinueSignals = /* @__PURE__ */ new Map();
+  const sessionStore = new SessionStore(resolvedDir);
+  const heatmapStore = new HeatmapStore();
+  const routes = registerRoutes(service, resolvedDir, wsManager, breakpointContinueSignals, sessionStore, heatmapStore);
+  const handler = createHandler(routes, staticDir);
+  httpServer.on("request", (req, res) => {
+    handler(req, res).catch((err) => {
+      log.error("Unhandled error:", err);
+      if (!res.headersSent) {
+        sendJson(res, { error: "Internal Server Error" }, 500);
+      }
+    });
+  });
+  const watchers = /* @__PURE__ */ new Map();
+  function createProjectWatcher(projectName, projectDir2, projectService) {
+    return new FileWatcher(
+      projectDir2,
+      async (file) => {
+        const content = await readFile7(
+          path4.join(projectDir2, file),
+          "utf-8"
+        ).catch(() => null);
+        if (content !== null) {
+          wsManager.broadcast(projectName, { type: "file:changed", file, content });
+        }
+        try {
+          const graph = await projectService.readGraph(file);
+          const graphJson = serializeGraphModel(graph);
+          wsManager.broadcast(projectName, { type: "graph:update", file, graph: graphJson });
+        } catch {
+        }
+      },
+      (file) => {
+        wsManager.broadcast(projectName, { type: "file:added", file });
+        projectService.listFiles().then((files) => {
+          wsManager.broadcast(projectName, { type: "tree:updated", files });
+        }).catch((err) => {
+          log.error(`Failed to list files for ${projectName} after add:`, err);
+        });
+      },
+      (file) => {
+        wsManager.broadcast(projectName, { type: "file:removed", file });
+        projectService.listFiles().then((files) => {
+          wsManager.broadcast(projectName, { type: "tree:updated", files });
+        }).catch((err) => {
+          log.error(`Failed to list files for ${projectName} after remove:`, err);
+        });
+      }
+    );
+  }
+  const fileWatcher = createProjectWatcher("default", resolvedDir, service);
+  watchers.set("default", fileWatcher);
+  function addProject(name, dir) {
+    const resolvedProjectDir = path4.resolve(dir);
+    const projectService = new DiagramService(resolvedProjectDir);
+    wsManager.addProject(name);
+    watchers.set(name, createProjectWatcher(name, resolvedProjectDir, projectService));
+  }
+  async function closeAllWatchers() {
+    for (const w of watchers.values()) {
+      await w.close();
+    }
+    watchers.clear();
+  }
+  return { httpServer, wsManager, fileWatcher, breakpointContinueSignals, sessionStore, heatmapStore, addProject, closeAllWatchers };
+}
+async function startServer(options) {
+  const projectDir = path4.resolve(options.dir);
+  const actualPort = await detect(options.port);
+  if (actualPort !== options.port) {
+    log.warn(`Port ${options.port} is in use, using port ${actualPort}`);
+  }
+  const service = new DiagramService(projectDir);
+  const { httpServer, wsManager, closeAllWatchers } = createHttpServer(projectDir, service);
+  const mmdFiles = await service.listFiles();
+  if (mmdFiles.length === 0) {
+    log.warn("No .mmd files found in " + projectDir);
+    log.warn("Run 'smartcode init' to create a sample diagram, or create a .mmd file manually.");
+  }
+  httpServer.listen(actualPort, () => {
+    const url = `http://localhost:${actualPort}`;
+    log.info(`Server running at ${url}`);
+    log.info(`Serving diagrams from ${projectDir}`);
+    if (options.openBrowser) {
+      open(url).catch(() => {
+        log.warn("Could not open browser automatically");
+      });
+    }
+  });
+  await register(projectDir, actualPort).catch((err) => {
+    log.warn("Failed to register workspace:", err instanceof Error ? err.message : err);
+  });
+  process.once("SIGINT", async () => {
+    log.info("Shutting down...");
+    const shutdownTimeout = setTimeout(() => {
+      log.warn("Shutdown timed out after 5s, forcing exit");
+      process.exit(1);
+    }, 5e3);
+    try {
+      await deregister(actualPort).catch(() => {
+      });
+      await closeAllWatchers().catch(() => {
+      });
+      wsManager.close();
+      await new Promise((resolve) => httpServer.close(() => resolve()));
+    } finally {
+      clearTimeout(shutdownTimeout);
+      process.exit(0);
+    }
+  });
+}
+var LOCALHOST_PATTERNS, MAX_BODY_SIZE;
+var init_server = __esm({
+  "src/server/server.ts"() {
+    "use strict";
+    init_service();
+    init_paths();
+    init_logger();
+    init_static();
+    init_routes();
+    init_websocket();
+    init_file_watcher();
+    init_graph_serializer();
+    init_session_store();
+    init_heatmap_routes();
+    init_workspace_registry();
+    LOCALHOST_PATTERNS = [
+      /^https?:\/\/localhost(:\d+)?$/,
+      /^https?:\/\/127\.0\.0\.1(:\d+)?$/,
+      /^https?:\/\/\[::1\](:\d+)?$/
+    ];
+    MAX_BODY_SIZE = 1 * 1024 * 1024;
+  }
+});
+
+// src/cli/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initProject: () => initProject
+});
+import { writeFile as writeFile4, access } from "fs/promises";
+import path5 from "path";
+import pc2 from "picocolors";
+async function initProject(dir, force) {
+  const resolvedDir = path5.resolve(dir);
+  const configPath = path5.join(resolvedDir, ".smartcode.json");
+  const diagramPath = path5.join(resolvedDir, "reasoning.mmd");
+  const exists = await access(configPath).then(() => true).catch(() => false);
+  if (exists && !force) {
+    throw new Error(
+      "Already initialized: .smartcode.json exists. Use --force to reinitialize."
+    );
+  }
+  await writeFile4(configPath, JSON.stringify(DEFAULT_CONFIG2, null, 2) + "\n", "utf-8");
+  const mcpPath = path5.join(resolvedDir, ".mcp.json");
+  const mcpExists = await access(mcpPath).then(() => true).catch(() => false);
+  if (!mcpExists || force) {
+    await writeFile4(mcpPath, JSON.stringify(MCP_CONFIG, null, 2) + "\n", "utf-8");
+  }
+  const diagramExists = await access(diagramPath).then(() => true).catch(() => false);
+  if (!diagramExists || force) {
+    await writeFile4(diagramPath, SAMPLE_DIAGRAM, "utf-8");
+  }
+  log.info(pc2.green("Initialized SmartCode"));
+  log.info(pc2.dim(`  ${configPath}`));
+  log.info(pc2.dim(`  ${mcpPath}`));
+  log.info(pc2.dim(`  ${diagramPath}`));
+  log.info("");
+  log.info(`Open this project in ${pc2.cyan("Claude Code")} or ${pc2.cyan("Cursor")} \u2014 SmartCode starts automatically.`);
+  log.info(`Or run ${pc2.cyan("smartcode serve")} to start the viewer manually.`);
+}
+var DEFAULT_CONFIG2, MCP_CONFIG, SAMPLE_DIAGRAM;
+var init_init = __esm({
+  "src/cli/init.ts"() {
+    "use strict";
+    init_logger();
+    DEFAULT_CONFIG2 = {
+      version: 1,
+      diagramDir: ".",
+      port: 3333
+    };
+    MCP_CONFIG = {
+      mcpServers: {
+        "smartcode": {
+          command: "smartcode",
+          args: ["mcp", "--serve"]
+        }
+      }
+    };
+    SAMPLE_DIAGRAM = `flowchart LR
+    Start["Problem Statement"] --> Analyze["Analyze Requirements"]
+    Analyze --> Plan["Create Plan"]
+    Plan --> Implement["Implement Solution"]
+    Implement --> Verify["Verify Results"]
+    Verify --> Done["Complete"]
+`;
+  }
+});
+
+// src/cli/status.ts
+var status_exports = {};
+__export(status_exports, {
+  formatUptime: () => formatUptime,
+  showStatus: () => showStatus
+});
+import { request } from "http";
+import pc3 from "picocolors";
+function formatUptime(seconds) {
+  const hrs = Math.floor(seconds / 3600);
+  const mins = Math.floor(seconds % 3600 / 60);
+  const secs = Math.floor(seconds % 60);
+  const parts = [];
+  if (hrs > 0) parts.push(`${hrs}h`);
+  if (mins > 0) parts.push(`${mins}m`);
+  if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
+  return parts.join(" ");
+}
+async function showStatus(port) {
+  try {
+    const data = await fetchStatus(port);
+    log.info(pc3.green("Server is running"));
+    log.info(`  Port:       ${port}`);
+    log.info(`  Uptime:     ${formatUptime(data.uptime)}`);
+    log.info(`  Project:    ${data.projectDir}`);
+    log.info(`  Files:      ${data.files}`);
+    log.info(`  Clients:    ${data.connectedClients}`);
+    log.info(`  Flags:      ${data.activeFlags.length}`);
+    if (data.activeFlags.length > 0) {
+      log.info("");
+      log.info(pc3.yellow("Active Flags:"));
+      for (const flag of data.activeFlags) {
+        log.info(`  ${pc3.dim(flag.file)} ${flag.nodeId}: ${flag.message}`);
+      }
+    }
+  } catch {
+    log.info(pc3.red("Server is not running"));
+    log.info(`  Tried port: ${port}`);
+    log.info(`  Run ${pc3.cyan("smartcode serve")} to start the server`);
+  }
+}
+function fetchStatus(port) {
+  return new Promise((resolve, reject) => {
+    const req = request(
+      {
+        hostname: "localhost",
+        port,
+        path: "/api/status",
+        method: "GET",
+        timeout: 3e3
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          try {
+            const body = Buffer.concat(chunks).toString("utf-8");
+            resolve(JSON.parse(body));
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    req.end();
+  });
+}
+var init_status = __esm({
+  "src/cli/status.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/mcp/schemas.ts
+import { z } from "zod";
+var UpdateDiagramInput, ReadFlagsInput, GetDiagramContextInput, UpdateNodeStatusInput, GetCorrectionContextInput, CheckBreakpointsInput, RecordGhostPathInput, CreateMcpSessionInput, StartSessionInput, RecordStepInput, EndSessionInput, SetRiskLevelInput;
+var init_schemas = __esm({
+  "src/mcp/schemas.ts"() {
+    "use strict";
+    UpdateDiagramInput = {
+      filePath: z.string().describe(
+        'Relative path to the .mmd file (e.g., "reasoning.mmd")'
+      ),
+      content: z.string().describe("Full Mermaid diagram content"),
+      nodeStatuses: z.record(
+        z.string(),
+        z.enum(["ok", "problem", "in-progress", "discarded"])
+      ).optional().describe(
+        'Node status colors. Map of nodeId to status. Example: {"ANALYZE": "ok", "PLAN": "in-progress", "DEPLOY": "problem"}'
+      ),
+      riskLevels: z.record(
+        z.string(),
+        z.object({
+          level: z.enum(["high", "medium", "low"]),
+          reason: z.string()
+        })
+      ).optional().describe(
+        'Risk assessments per node. Example: {"DEPLOY": {"level": "high", "reason": "touches production DB"}}'
+      ),
+      ghostPaths: z.array(
+        z.object({
+          from: z.string(),
+          to: z.string(),
+          label: z.string().optional()
+        })
+      ).optional().describe(
+        'Rejected alternatives. Example: [{"from": "A", "to": "C", "label": "Skipped: too risky"}]'
+      )
+    };
+    ReadFlagsInput = {
+      filePath: z.string().describe(
+        "Relative path to the .mmd file to read flags from"
+      )
+    };
+    GetDiagramContextInput = {
+      filePath: z.string().describe(
+        "Relative path to the .mmd file to get context for"
+      )
+    };
+    UpdateNodeStatusInput = {
+      filePath: z.string().describe("Relative path to the .mmd file"),
+      nodeId: z.string().describe("ID of the node to update status for"),
+      status: z.enum(["ok", "problem", "in-progress", "discarded"]).describe("Status to set on the node")
+    };
+    GetCorrectionContextInput = {
+      filePath: z.string().describe("Relative path to the .mmd file"),
+      nodeId: z.string().describe("ID of the flagged node to get correction context for")
+    };
+    CheckBreakpointsInput = {
+      filePath: z.string().describe("Relative path to the .mmd file"),
+      currentNodeId: z.string().describe("Node ID the AI is currently processing")
+    };
+    RecordGhostPathInput = {
+      filePath: z.string().describe("Relative path to the .mmd file"),
+      fromNodeId: z.string().describe("Source node of the discarded path"),
+      toNodeId: z.string().describe("Target node of the discarded path"),
+      label: z.string().optional().describe("Optional reason for discarding this path")
+    };
+    CreateMcpSessionInput = {
+      label: z.string().optional().describe(
+        'Human-readable label for this session (e.g., "Debug auth bug"). Auto-generated if not provided.'
+      )
+    };
+    StartSessionInput = {
+      filePath: z.string().describe("Relative path to the .mmd file to record a session for")
+    };
+    RecordStepInput = {
+      sessionId: z.string().describe("ID of the active session to record a step in"),
+      nodeId: z.string().describe("ID of the node being visited"),
+      action: z.string().describe('Description of the action taken (e.g., "analyzed", "modified", "flagged")'),
+      metadata: z.record(z.string(), z.unknown()).optional().describe("Optional metadata about this step")
+    };
+    EndSessionInput = {
+      sessionId: z.string().describe("ID of the active session to end")
+    };
+    SetRiskLevelInput = {
+      filePath: z.string().describe("Relative path to the .mmd file"),
+      nodeId: z.string().describe("ID of the node to set risk level on"),
+      level: z.enum(["high", "medium", "low"]).describe("Risk level: high, medium, or low"),
+      reason: z.string().describe("Reason for the risk assessment")
+    };
+  }
+});
+
+// src/mcp/session-tools.ts
+function registerSessionTools(server, service, options) {
+  server.registerTool(
+    "start_session",
+    {
+      description: "Start a new recording session for a diagram file. Returns a session ID used by record_step and end_session. Sessions are persisted as JSONL files.",
+      inputSchema: StartSessionInput
+    },
+    async ({ filePath }) => {
+      try {
+        const sessionStore = options?.sessionStore;
+        if (!sessionStore) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Session recording unavailable: no session store (requires --serve mode)"
+              }
+            ],
+            isError: true
+          };
+        }
+        const sessionId = await sessionStore.startSession(filePath);
+        if (options?.mcpSessionRegistry) {
+          options.mcpSessionRegistry.trackDiagram(filePath).catch(() => {
+          });
+          if (options?.wsManager) {
+            options.wsManager.broadcastAll({ type: "mcp-session:updated" });
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ sessionId, message: "Session started" })
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "record_step",
+    {
+      description: "Record a step in an active session. Each step represents a node visit with an action description. The event is persisted to the session JSONL file and optionally broadcast via WebSocket.",
+      inputSchema: RecordStepInput
+    },
+    async ({ sessionId, nodeId, action, metadata }) => {
+      try {
+        const sessionStore = options?.sessionStore;
+        if (!sessionStore) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Session recording unavailable: no session store (requires --serve mode)"
+              }
+            ],
+            isError: true
+          };
+        }
+        const event = {
+          ts: Date.now(),
+          type: "node:visited",
+          payload: { nodeId, action, ...metadata }
+        };
+        await sessionStore.recordStep(sessionId, event);
+        if (options?.wsManager) {
+          options.wsManager.broadcastAll({
+            type: "session:event",
+            sessionId,
+            event: { ts: event.ts, type: event.type, payload: event.payload }
+          });
+          const activeMeta = sessionStore.getActiveSession(sessionId);
+          if (activeMeta?.diagramFile) {
+            options.wsManager.broadcastAll({
+              type: "heatmap:update",
+              file: activeMeta.diagramFile,
+              data: { [nodeId]: 1 }
+            });
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ recorded: true })
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "end_session",
+    {
+      description: "End an active recording session. Returns a summary with statistics (duration, nodes visited, edges traversed). If a WebSocket manager is available, broadcasts updated heatmap data.",
+      inputSchema: EndSessionInput
+    },
+    async ({ sessionId }) => {
+      try {
+        const sessionStore = options?.sessionStore;
+        if (!sessionStore) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Session recording unavailable: no session store (requires --serve mode)"
+              }
+            ],
+            isError: true
+          };
+        }
+        const summary = await sessionStore.endSession(sessionId);
+        if (options?.wsManager && summary.diagramFile) {
+          const heatmapData = await sessionStore.getHeatmapData(summary.diagramFile);
+          options.wsManager.broadcastAll({
+            type: "heatmap:update",
+            file: summary.diagramFile,
+            data: heatmapData
+          });
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(summary, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "set_risk_level",
+    {
+      description: "Set a risk level annotation on a diagram node. Risk levels (high, medium, low) are persisted as @risk annotations in the .mmd file and rendered in the browser viewer.",
+      inputSchema: SetRiskLevelInput
+    },
+    async ({ filePath, nodeId, level, reason }) => {
+      try {
+        await service.setRisk(filePath, nodeId, level, reason);
+        if (options?.mcpSessionRegistry) {
+          options.mcpSessionRegistry.trackDiagram(filePath).catch(() => {
+          });
+          if (options?.wsManager) {
+            options.wsManager.broadcastAll({ type: "mcp-session:updated" });
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ set: true, nodeId, level })
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+var init_session_tools = __esm({
+  "src/mcp/session-tools.ts"() {
+    "use strict";
+    init_schemas();
+  }
+});
+
+// src/mcp/tools.ts
+function registerTools(server, service, options) {
+  server.registerTool(
+    "update_diagram",
+    {
+      description: "Create or update a Mermaid diagram (.mmd file) with optional annotations \u2014 all in ONE call. Pass nodeStatuses to color nodes (ok=green, problem=red, in-progress=yellow, discarded=gray). Pass riskLevels to flag risky nodes with reasons. Pass ghostPaths to show rejected alternatives as dashed edges. Changes appear in the browser viewer within 100ms via WebSocket.",
+      inputSchema: UpdateDiagramInput
+    },
+    async ({ filePath, content, nodeStatuses, riskLevels, ghostPaths }) => {
+      try {
+        const statusMap = nodeStatuses ? new Map(Object.entries(nodeStatuses)) : void 0;
+        const riskMap = riskLevels ? new Map(
+          Object.entries(riskLevels).map(([nodeId, r]) => [
+            nodeId,
+            { nodeId, level: r.level, reason: r.reason }
+          ])
+        ) : void 0;
+        const ghostAnnotations = ghostPaths && ghostPaths.length > 0 ? ghostPaths.map((gp) => ({
+          fromNodeId: gp.from,
+          toNodeId: gp.to,
+          label: gp.label ?? ""
+        })) : void 0;
+        await service.writeDiagramPreserving(filePath, content, statusMap, riskMap, ghostAnnotations);
+        if (options?.mcpSessionRegistry) {
+          options.mcpSessionRegistry.trackDiagram(filePath).catch(() => {
+          });
+          if (options?.wsManager) {
+            options.wsManager.broadcastAll({ type: "mcp-session:updated" });
+          }
+        }
+        if (ghostAnnotations && ghostAnnotations.length > 0 && options?.wsManager) {
+          const allGhosts = await service.getGhosts(filePath);
+          options.wsManager.broadcastAll({
+            type: "ghost:update",
+            file: filePath,
+            ghostPaths: allGhosts
+          });
+        }
+        const parts = [`Diagram updated: ${filePath}`];
+        if (statusMap && statusMap.size > 0) parts.push(`${statusMap.size} node statuses set`);
+        if (riskMap && riskMap.size > 0) parts.push(`${riskMap.size} risk levels set`);
+        if (ghostPaths && ghostPaths.length > 0) parts.push(`${ghostPaths.length} ghost paths recorded`);
+        return {
+          content: [{ type: "text", text: parts.join(". ") + "." }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "read_flags",
+    {
+      description: "Read all active developer flags from a .mmd diagram file. Flags are annotations added by developers to signal issues or requests to the AI.",
+      inputSchema: ReadFlagsInput
+    },
+    async ({ filePath }) => {
+      try {
+        const flags = await service.getFlags(filePath);
+        const result = flags.map((f) => ({
+          nodeId: f.nodeId,
+          message: f.message
+        }));
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "get_diagram_context",
+    {
+      description: "Get the current state of a diagram including Mermaid content, flags, node statuses, and validation info. Use this to understand the diagram before making changes.",
+      inputSchema: GetDiagramContextInput
+    },
+    async ({ filePath }) => {
+      try {
+        const diagram = await service.readDiagram(filePath);
+        const context = {
+          filePath: diagram.filePath,
+          mermaidContent: diagram.mermaidContent,
+          flags: Array.from(diagram.flags.values()).map((f) => ({
+            nodeId: f.nodeId,
+            message: f.message
+          })),
+          statuses: Object.fromEntries(diagram.statuses),
+          breakpoints: Array.from(diagram.breakpoints),
+          risks: Array.from(diagram.risks.values()).map((r) => ({
+            nodeId: r.nodeId,
+            level: r.level,
+            reason: r.reason
+          })),
+          ghostPaths: diagram.ghosts.map((gp) => ({
+            fromNodeId: gp.fromNodeId,
+            toNodeId: gp.toNodeId,
+            label: gp.label
+          })),
+          validation: {
+            valid: diagram.validation.valid,
+            errors: diagram.validation.errors,
+            diagramType: diagram.validation.diagramType
+          }
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(context, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "update_node_status",
+    {
+      description: 'Set the status of a specific node in a diagram. Status values: "ok" (green), "problem" (red), "in-progress" (yellow), "discarded" (gray). Status renders as color in the browser viewer.',
+      inputSchema: UpdateNodeStatusInput
+    },
+    async ({ filePath, nodeId, status }) => {
+      try {
+        await service.setStatus(filePath, nodeId, status);
+        if (options?.mcpSessionRegistry) {
+          options.mcpSessionRegistry.trackDiagram(filePath).catch(() => {
+          });
+          if (options?.wsManager) {
+            options.wsManager.broadcastAll({ type: "mcp-session:updated" });
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Node "${nodeId}" status set to "${status}" in ${filePath}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "get_correction_context",
+    {
+      description: "Get structured correction context for a flagged diagram node. Returns the flag message, node context (statuses, other flags), the full diagram content, and a natural language instruction for making corrections. Use this when a developer has flagged a node for correction.",
+      inputSchema: GetCorrectionContextInput
+    },
+    async ({ filePath, nodeId }) => {
+      try {
+        const diagram = await service.readDiagram(filePath);
+        const flag = diagram.flags.get(nodeId);
+        if (!flag) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No flag found on node "${nodeId}" in ${filePath}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const context = {
+          correction: {
+            nodeId: flag.nodeId,
+            flagMessage: flag.message
+          },
+          diagramState: {
+            filePath,
+            mermaidContent: diagram.mermaidContent,
+            allFlags: Array.from(diagram.flags.values()).map((f) => ({
+              nodeId: f.nodeId,
+              message: f.message
+            })),
+            statuses: Object.fromEntries(diagram.statuses)
+          },
+          instruction: `The developer flagged node "${nodeId}" with the message: "${flag.message}". Review the diagram and update it to address this feedback. Use the update_diagram tool to write the corrected Mermaid content.`
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(context, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "check_breakpoints",
+    {
+      description: 'Check if the current node has a breakpoint set. Returns "pause" if a breakpoint exists and no continue signal is pending, "continue" otherwise. The AI should respect the pause signal by waiting and re-checking.',
+      inputSchema: CheckBreakpointsInput
+    },
+    async ({ filePath, currentNodeId }) => {
+      try {
+        const breakpoints = await service.getBreakpoints(filePath);
+        if (breakpoints.has(currentNodeId)) {
+          const signalKey = `${filePath}:${currentNodeId}`;
+          const continueSignals = options?.breakpointContinueSignals;
+          if (continueSignals && continueSignals.has(signalKey)) {
+            continueSignals.delete(signalKey);
+            if (options?.wsManager) {
+              options.wsManager.broadcastAll({
+                type: "breakpoint:continue",
+                file: filePath,
+                nodeId: currentNodeId
+              });
+            }
+            return {
+              content: [{ type: "text", text: "continue" }]
+            };
+          }
+          if (options?.wsManager) {
+            options.wsManager.broadcastAll({
+              type: "breakpoint:hit",
+              file: filePath,
+              nodeId: currentNodeId
+            });
+          }
+          return {
+            content: [{ type: "text", text: "pause" }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: "continue" }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "record_ghost_path",
+    {
+      description: "Record a discarded reasoning branch as a ghost path. Ghost paths are displayed as dashed translucent edges in the browser viewer.",
+      inputSchema: RecordGhostPathInput
+    },
+    async ({ filePath, fromNodeId, toNodeId, label }) => {
+      try {
+        if (options?.mcpSessionRegistry) {
+          options.mcpSessionRegistry.trackDiagram(filePath).catch(() => {
+          });
+          if (options?.wsManager) {
+            options.wsManager.broadcastAll({ type: "mcp-session:updated" });
+          }
+        }
+        await service.addGhost(filePath, fromNodeId, toNodeId, label ?? "");
+        if (options?.wsManager) {
+          const allGhosts = await service.getGhosts(filePath);
+          options.wsManager.broadcastAll({
+            type: "ghost:update",
+            file: filePath,
+            ghostPaths: allGhosts
+          });
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Ghost path recorded: ${fromNodeId} -> ${toNodeId}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "create_mcp_session",
+    {
+      description: "Start a new MCP session to group diagrams for this conversation. Call at the start of each conversation to keep diagrams organized.",
+      inputSchema: CreateMcpSessionInput
+    },
+    async ({ label }) => {
+      try {
+        if (!options?.mcpSessionRegistry) {
+          return {
+            content: [{ type: "text", text: "MCP sessions require --serve mode" }],
+            isError: true
+          };
+        }
+        const sessionId = await options.mcpSessionRegistry.createSession(label);
+        if (options?.wsManager) {
+          options.wsManager.broadcastAll({ type: "mcp-session:updated" });
+        }
+        return {
+          content: [{ type: "text", text: `Session created: ${sessionId} (label: ${label || "auto"})` }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
+    }
+  );
+  registerSessionTools(server, service, {
+    sessionStore: options?.sessionStore,
+    wsManager: options?.wsManager,
+    mcpSessionRegistry: options?.mcpSessionRegistry
+  });
+}
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
+    "use strict";
+    init_schemas();
+    init_session_tools();
+  }
+});
+
+// src/mcp/resources.ts
+import {
+  ResourceTemplate
+} from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server, service) {
+  server.registerResource(
+    "diagram-list",
+    "smartcode://diagrams",
+    {
+      title: "Available Diagrams",
+      description: "List of all .mmd diagram files in the project",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const files = await service.listFiles();
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify({ files })
+          }
+        ]
+      };
+    }
+  );
+  const diagramTemplate = new ResourceTemplate(
+    "smartcode://diagrams/{filePath}",
+    {
+      list: async () => {
+        const files = await service.listFiles();
+        return {
+          resources: files.map((f) => ({
+            uri: `smartcode://diagrams/${encodeURIComponent(f)}`,
+            name: f
+          }))
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "diagram-content",
+    diagramTemplate,
+    {
+      title: "Diagram Content",
+      description: "Content of a specific .mmd diagram file",
+      mimeType: "text/plain"
+    },
+    async (_uri, variables) => {
+      try {
+        const filePath = decodeURIComponent(
+          String(variables.filePath)
+        );
+        const diagram = await service.readDiagram(filePath);
+        return {
+          contents: [
+            {
+              uri: _uri.href,
+              mimeType: "text/plain",
+              text: diagram.mermaidContent
+            }
+          ]
+        };
+      } catch {
+        return { contents: [] };
+      }
+    }
+  );
+}
+var init_resources = __esm({
+  "src/mcp/resources.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/instructions.ts
+var MCP_INSTRUCTIONS;
+var init_instructions = __esm({
+  "src/mcp/instructions.ts"() {
+    "use strict";
+    MCP_INSTRUCTIONS = `
+# SmartCode \u2014 Show Your Reasoning Visually
+
+You have SmartCode. Use it to show the developer your reasoning in real-time
+as a visual flowchart in their browser. ONE tool call = complete diagram with colors,
+risks, and rejected alternatives.
+
+## Session Management
+
+At the START of each conversation, call \`create_mcp_session\` with a descriptive label:
+\`\`\`json
+{ "label": "Debug auth bug" }
+\`\`\`
+This groups all diagrams from this conversation into one session visible in the browser.
+If you forget, diagrams still work but will go into a default session.
+
+## When to Use (PROACTIVELY, without being asked)
+
+- Planning any implementation with 3+ steps
+- Debugging: show your hypothesis tree
+- Refactoring: show before/after or decision points
+- Architecture analysis: show components and data flow
+- Any task where visualizing your plan prevents wasted effort
+
+Do NOT use for: one-line fixes, simple answers, obvious tasks.
+
+## How to Use: ONE Call Does Everything
+
+\`update_diagram\` accepts everything at once \u2014 diagram + annotations:
+
+\`\`\`json
+{
+  "filePath": "reasoning.mmd",
+  "content": "flowchart TD\\n  ANALYZE[\\"Analyze Code\\"] --> PLAN[\\"Create Plan\\"]\\n  PLAN --> IMPL[\\"Implement\\"]\\n  IMPL --> TEST[\\"Run Tests\\"]",
+  "nodeStatuses": {
+    "ANALYZE": "ok",
+    "PLAN": "in-progress",
+    "IMPL": "problem"
+  },
+  "riskLevels": {
+    "IMPL": { "level": "high", "reason": "Touches auth module, could break login flow" }
+  },
+  "ghostPaths": [
+    { "from": "ANALYZE", "to": "IMPL", "label": "Skip planning: rejected, too complex" }
+  ]
+}
+\`\`\`
+
+### Status Colors (nodeStatuses)
+- **"ok"** (green) = verified, working, done
+- **"in-progress"** (yellow) = currently working on this
+- **"problem"** (red) = found issue, needs attention
+- **"discarded"** (gray) = ruled out, not pursuing
+
+### Risk Levels (riskLevels)
+- **"high"** = likely bugs, edge cases, or failures \u2014 ALWAYS explain why
+- **"medium"** = moderate complexity, worth watching
+- **"low"** = straightforward
+
+### Ghost Paths (ghostPaths)
+Alternatives you considered but rejected. Include WHY you rejected them.
+
+## Diagram Design Rules
+
+- **Max 15 nodes** \u2014 be concise, not comprehensive
+- **Short labels** \u2014 "Validate Input" not "Validate all user input fields and return errors"
+- **Meaningful IDs** \u2014 use \`VALIDATE\` not \`A\` or \`node1\`
+- **Use subgraphs** to group phases
+- **TD** for sequential flows, **LR** for comparison/parallel
+
+## CRITICAL: Never Block Work for Diagrams
+
+**NEVER stop your workflow just to update a diagram.** Diagram calls must NOT interrupt your task flow.
+
+Rules:
+1. **Always batch diagram calls with other tool calls** \u2014 if you're about to run a command, edit a file, or read something, include the \`update_diagram\` call in the SAME parallel tool call batch. Never make a dedicated turn just for a diagram.
+2. **If you have nothing else to do in this turn**, then a standalone diagram call is OK (e.g., initial plan before starting work, or final summary).
+3. **Prefer fewer, bigger updates** over many small ones. Update the diagram 2-3 times max per task: plan, mid-progress, done.
+
+Good pattern:
+\`\`\`
+Turn 1: [update_diagram (plan)] + [read_file] \u2014 parallel
+Turn 2: [edit_file] + [update_diagram (progress)] \u2014 parallel
+Turn 3: [run_tests] + [update_diagram (final)] \u2014 parallel
+\`\`\`
+
+Bad pattern (NEVER do this):
+\`\`\`
+Turn 1: [read_file]
+Turn 2: [update_diagram] \u2190 BLOCKING! Wasted turn
+Turn 3: [edit_file]
+Turn 4: [update_diagram] \u2190 BLOCKING again!
+\`\`\`
+
+## Workflow During a Task
+
+1. **Before coding**: Create diagram showing your plan \u2014 batch it with your first read/search call
+2. **As you work**: Update statuses \u2014 batch it with your next edit/command call
+3. **When done**: Final update with all nodes green (ok) or red (problem) \u2014 batch with summary
+
+Each update is ONE \`update_diagram\` call \u2014 fast and fluid.
+
+## Incremental Updates
+
+For small changes to an existing diagram, you can also use:
+- \`update_node_status\` \u2014 change one node's color
+- \`set_risk_level\` \u2014 add/change one risk assessment
+- \`record_ghost_path\` \u2014 add one rejected alternative
+
+But prefer \`update_diagram\` for initial creation and major updates.
+
+## Developer Feedback (Flags)
+
+Use \`read_flags\` to check if the developer flagged any nodes for correction.
+If flags exist, use \`get_correction_context\` to understand what they want.
+
+## Sessions (Optional, for long tasks)
+
+For tasks spanning many steps, use sessions to generate heatmaps:
+- \`start_session\` \u2192 \`record_step\` per node \u2192 \`end_session\`
+
+## Breakpoints
+
+If \`check_breakpoints\` returns "pause", STOP and wait for the developer.
+`.trim();
+  }
+});
+
+// src/mcp/server.ts
+var server_exports2 = {};
+__export(server_exports2, {
+  createMcpServer: () => createMcpServer,
+  startMcpServer: () => startMcpServer
+});
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function createMcpServer(service, deps) {
+  const server = new McpServer2(
+    { name: "smartcode", version: getVersion() },
+    { instructions: MCP_INSTRUCTIONS }
+  );
+  registerTools(server, service, deps);
+  registerResources(server, service);
+  log.debug("MCP server created");
+  return server;
+}
+async function startMcpServer(options) {
+  const { resolve } = await import("path");
+  const { DiagramService: DiagramService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+  const resolvedDir = resolve(options.dir);
+  const service = new DiagramService2(resolvedDir);
+  const transport = new StdioServerTransport();
+  let httpCleanup;
+  let deps;
+  if (options.serve) {
+    const { createHttpServer: createHttpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const { detect: detect2 } = await import("detect-port");
+    const preferredPort = options.port ?? 3333;
+    const actualPort = await detect2(preferredPort);
+    if (actualPort !== preferredPort) {
+      log.warn(`Port ${preferredPort} is in use, using port ${actualPort}`);
+    }
+    const { httpServer, wsManager, breakpointContinueSignals, sessionStore, closeAllWatchers } = createHttpServer2(resolvedDir, service);
+    deps = { wsManager, breakpointContinueSignals, sessionStore };
+    await new Promise((resolvePromise) => {
+      httpServer.listen(actualPort, () => {
+        log.info(`HTTP+WS server running at http://localhost:${actualPort}`);
+        resolvePromise();
+      });
+    });
+    await register(resolvedDir, actualPort).catch((err) => {
+      log.warn("Failed to register workspace:", err instanceof Error ? err.message : err);
+    });
+    const mcpRegistry = new McpSessionRegistry(resolvedDir);
+    await mcpRegistry.register().catch((err) => {
+      log.warn("Failed to register MCP session:", err instanceof Error ? err.message : err);
+    });
+    deps.mcpSessionRegistry = mcpRegistry;
+    httpCleanup = async () => {
+      log.info("Shutting down HTTP+WS server...");
+      await deregister(actualPort).catch(() => {
+      });
+      if (deps?.mcpSessionRegistry) {
+        await deps.mcpSessionRegistry.deregister().catch(() => {
+        });
+      }
+      await closeAllWatchers();
+      wsManager.close();
+      await new Promise((resolveClose) => {
+        httpServer.close(() => resolveClose());
+      });
+    };
+  }
+  const server = createMcpServer(service, deps);
+  await server.connect(transport);
+  log.info(`MCP server running on stdio (project: ${resolvedDir})`);
+  const shutdown = async () => {
+    log.info("Shutting down MCP server...");
+    if (httpCleanup) {
+      await httpCleanup();
+    }
+    process.exit(0);
+  };
+  process.stdin.on("end", shutdown);
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+var init_server2 = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_tools();
+    init_resources();
+    init_instructions();
+    init_logger();
+    init_workspace_registry();
+    init_mcp_session_registry();
+    init_version();
+  }
+});
+
+// src/cli.ts
+init_version();
+import { Command } from "commander";
+var program = new Command();
+program.name("smartcode").description("AI observability diagrams -- see what your AI is thinking").version(getVersion());
+program.command("serve").description("Start the diagram viewer server").option("-p, --port <number>", "port number", "3333").option("-d, --dir <path>", "project directory", ".").option("--no-open", "do not open browser automatically").action(async (options) => {
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startServer2({
+    port: parseInt(options.port, 10),
+    dir: options.dir,
+    openBrowser: options.open
+  });
+});
+program.command("init").description("Initialize a SmartCode project").option("-d, --dir <path>", "project directory", ".").option("-f, --force", "overwrite existing config").action(async (options) => {
+  const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  await initProject2(options.dir, options.force);
+});
+program.command("status").description("Show status of the running SmartCode server").option("-p, --port <number>", "server port to check", "3333").action(async (options) => {
+  const { showStatus: showStatus2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  await showStatus2(parseInt(options.port, 10));
+});
+program.command("mcp").description("Start the MCP server for AI tool integration (stdio transport)").option("-d, --dir <path>", "project directory", ".").option("-s, --serve", "also start HTTP+WS server for browser viewing").option("-p, --port <number>", "HTTP server port (requires --serve)", "3333").action(async (options) => {
+  const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
+  await startMcpServer2({
+    dir: options.dir,
+    serve: options.serve,
+    port: parseInt(options.port, 10)
+  });
+});
+program.parse();
+//# sourceMappingURL=cli.js.map