esedre 0.1.3

package/dist/esedre.mjs

@@ -0,0 +1,3683 @@
+#!/usr/bin/env node
+
+// bin/esedre.ts
+import fs8 from "node:fs";
+import path8 from "node:path";
+
+// src/storage/filesystem.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/types.ts
+var EsedreConflictError = class extends Error {
+  constructor(ticketId, currentHash, lastHash) {
+    super(
+      `Conflict: Ticket #${ticketId} has been modified (current: ${currentHash.slice(0, 8)}, provided lastHash: ${lastHash.slice(0, 8)}). Refresh state and retry.`
+    );
+    this.ticketId = ticketId;
+    this.currentHash = currentHash;
+    this.lastHash = lastHash;
+    this.name = "EsedreConflictError";
+  }
+  ticketId;
+  currentHash;
+  lastHash;
+};
+
+// src/config.ts
+import fs from "node:fs";
+import path from "node:path";
+var DEFAULT_ESEDRE_PORT = 5674;
+var MAX_PROJECT_CODE_LENGTH = 6;
+var PROJECT_CODE_REGEX = /^[a-zA-Z0-9]{1,6}$/;
+var EsedreAuthorizationError = class extends Error {
+  constructor(projectCode, message) {
+    super(message || `Access Denied: Project '${projectCode}' is outside this workspace's authorized scope.`);
+    this.projectCode = projectCode;
+    this.name = "EsedreAuthorizationError";
+  }
+  projectCode;
+};
+function validateProjectCode(code, existingCodes) {
+  if (!code || typeof code !== "string") {
+    return { valid: false, error: "Project code is required." };
+  }
+  const trimmed = code.trim();
+  if (!PROJECT_CODE_REGEX.test(trimmed)) {
+    return {
+      valid: false,
+      error: `Project code '${trimmed}' is invalid. It must be 1 to ${MAX_PROJECT_CODE_LENGTH} alphanumeric characters (e.g. CORE, WEB, DOCS).`
+    };
+  }
+  if (existingCodes && existingCodes.length > 0) {
+    const lower = trimmed.toLowerCase();
+    const collision = existingCodes.find((c) => c.trim().toLowerCase() === lower);
+    if (collision && collision !== trimmed) {
+      return {
+        valid: false,
+        error: `Project code '${trimmed}' collides with existing project '${collision}' (case-insensitive).`
+      };
+    }
+  }
+  return { valid: true };
+}
+function isProjectAuthorized(projectCode, allowedProjects) {
+  if (!allowedProjects || allowedProjects.length === 0) {
+    return true;
+  }
+  const normalizedList = allowedProjects.map((p) => p.trim().toUpperCase());
+  if (normalizedList.includes("*")) {
+    return true;
+  }
+  const normalized = projectCode.trim().toUpperCase();
+  return normalizedList.includes(normalized);
+}
+function findEsedreConfig(startDir) {
+  let current = path.resolve(startDir || process.cwd());
+  const candidates = [
+    [".esedre", "esedre.json"],
+    ["esedre.json"]
+  ];
+  while (true) {
+    for (const segs of candidates) {
+      const candidatePath = path.join(current, ...segs);
+      if (fs.existsSync(candidatePath)) {
+        try {
+          const raw = fs.readFileSync(candidatePath, "utf-8");
+          const parsed = JSON.parse(raw);
+          return {
+            config: parsed,
+            configPath: candidatePath,
+            workspaceRoot: current
+          };
+        } catch (err) {
+          throw new Error(`Failed to parse Esedre configuration at ${candidatePath}: ${err.message}`);
+        }
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return {
+    config: {},
+    configPath: null,
+    workspaceRoot: process.cwd()
+  };
+}
+function checkGitIgnore(workspaceRoot) {
+  const gitignorePath = path.join(workspaceRoot, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    return {
+      exists: false,
+      hasSnapshotIgnored: false,
+      gitignorePath
+    };
+  }
+  try {
+    const content = fs.readFileSync(gitignorePath, "utf-8");
+    const lines = content.split(/\r?\n/).map((l) => l.trim());
+    const hasSnapshotIgnored = lines.some(
+      (l) => l === ".esedre/snapshot.json" || l === "/.esedre/snapshot.json" || l === "snapshot.json" || l === ".esedre/*.json"
+    );
+    return {
+      exists: true,
+      hasSnapshotIgnored,
+      gitignorePath
+    };
+  } catch {
+    return {
+      exists: true,
+      hasSnapshotIgnored: false,
+      gitignorePath
+    };
+  }
+}
+function appendSnapshotToGitIgnore(workspaceRoot) {
+  const check = checkGitIgnore(workspaceRoot);
+  if (check.hasSnapshotIgnored) return false;
+  const entry = "\n# Esedre ticket local snapshot (read-only projection)\n.esedre/snapshot.json\n";
+  try {
+    if (check.exists) {
+      fs.appendFileSync(check.gitignorePath, entry, "utf-8");
+    } else {
+      fs.writeFileSync(check.gitignorePath, entry.trimStart(), "utf-8");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function migrateEsedreConfig(raw, targetVersion = "0.1.0") {
+  const migrated = {
+    version: targetVersion,
+    projectCode: raw?.projectCode || void 0,
+    allowedProjects: Array.isArray(raw?.allowedProjects) ? raw.allowedProjects : void 0,
+    dataDir: Array.isArray(raw?.dataDir) ? raw.dataDir : typeof raw?.dataDir === "string" ? raw.dataDir : void 0,
+    serverUrl: raw?.serverUrl,
+    port: typeof raw?.port === "number" ? raw.port : DEFAULT_ESEDRE_PORT,
+    projects: typeof raw?.projects === "object" && raw?.projects ? raw.projects : void 0
+  };
+  return migrated;
+}
+
+// src/snapshot.ts
+import crypto from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+function computeTicketHash(ticket) {
+  const hash = crypto.createHash("sha1");
+  const payload = JSON.stringify({
+    id: ticket.meta.id,
+    title: (ticket.meta.title || "").trim(),
+    category: ticket.meta.category,
+    status: ticket.meta.status,
+    complexity: ticket.meta.complexity || "",
+    effort: ticket.meta.estimatedEffort || "",
+    project: ticket.meta.project || "",
+    revision: ticket.meta.revision || 1,
+    completedAt: ticket.meta.completedAt || "",
+    detailRaw: (ticket.detail?.raw || "").trim(),
+    planMarkdown: (ticket.planMarkdown || "").trim()
+  });
+  hash.update(payload, "utf-8");
+  return hash.digest("hex");
+}
+function verifyTicketHash(currentHash, lastHash) {
+  if (!lastHash) return true;
+  const cleanLast = lastHash.trim().toLowerCase();
+  const cleanCurrent = currentHash.trim().toLowerCase();
+  if (cleanCurrent === cleanLast) return true;
+  if (cleanLast.length >= 7 && cleanCurrent.startsWith(cleanLast)) return true;
+  return false;
+}
+async function generateProjectSnapshot(storage, projectCode, outputDir) {
+  const tickets = await storage.listTickets({ project: projectCode });
+  const entries = [];
+  const now = Date.now();
+  for (const t of tickets) {
+    const lookupKey = t.projectDescriptor?.code ? `${t.projectDescriptor.code}-${t.meta.id}` : t.meta.id;
+    const fullTicket = await storage.getTicket(lookupKey);
+    const plan = await storage.getPlan(lookupKey);
+    const ticketObj = fullTicket || t;
+    ticketObj.planMarkdown = plan || void 0;
+    const pCode = ticketObj.projectDescriptor?.code || ticketObj.meta.project || projectCode;
+    const ticketKey = `${pCode}-${ticketObj.meta.id}`;
+    const createdAt = ticketObj.meta.createdAt || ticketObj.meta.timestamp;
+    const updatedAt = ticketObj.meta.updatedAt || ticketObj.meta.timestamp || createdAt;
+    const completedAt = ticketObj.meta.completedAt || (ticketObj.meta.status === "Completed" ? ticketObj.meta.timestamp : void 0);
+    const revision = ticketObj.meta.revision || 1;
+    let daysSinceUpdate = 0;
+    if (updatedAt) {
+      const updateTime = new Date(updatedAt).getTime();
+      if (!isNaN(updateTime)) {
+        daysSinceUpdate = Math.max(0, Math.floor((now - updateTime) / (1e3 * 60 * 60 * 24)));
+      }
+    }
+    const sha1 = computeTicketHash(ticketObj);
+    entries.push({
+      id: ticketObj.meta.id,
+      ticketKey,
+      title: ticketObj.meta.title,
+      type: ticketObj.meta.type || ticketObj.meta.category || "Feature",
+      category: ticketObj.meta.type || ticketObj.meta.category || "Feature",
+      status: ticketObj.meta.status,
+      complexity: ticketObj.meta.complexity,
+      estimatedEffort: ticketObj.meta.estimatedEffort,
+      project: pCode,
+      summary: ticketObj.detail?.summary,
+      hasPlan: Boolean(plan && plan.trim().length > 0),
+      planMarkdown: plan && plan.trim().length > 0 ? plan : void 0,
+      createdAt,
+      updatedAt,
+      completedAt,
+      revision,
+      daysSinceUpdate,
+      sha1
+    });
+  }
+  const snapshot = {
+    version: "0.1.0",
+    projectCode,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalTickets: entries.length,
+    tickets: entries
+  };
+  const esedreDir = path2.join(outputDir, ".esedre");
+  if (!fs2.existsSync(esedreDir)) {
+    fs2.mkdirSync(esedreDir, { recursive: true });
+  }
+  const snapshotPath = path2.join(esedreDir, "snapshot.json");
+  const tempSnapshotPath = `${snapshotPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs2.writeFileSync(tempSnapshotPath, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+    fs2.renameSync(tempSnapshotPath, snapshotPath);
+  } catch {
+    fs2.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+    if (fs2.existsSync(tempSnapshotPath)) {
+      try {
+        fs2.unlinkSync(tempSnapshotPath);
+      } catch {
+      }
+    }
+  }
+  return snapshot;
+}
+
+// src/storage/filesystem.ts
+function isProjectMatch(code, slug, filter) {
+  const f = filter.trim().toLowerCase();
+  const c = code.trim().toLowerCase();
+  const s = slug.trim().toLowerCase();
+  if (c === f || s === f) return true;
+  if ((f === "prof" || f === "core" || f === "pasrc") && (c === "prof" || c === "core")) return true;
+  if ((f === "esedre" || f === "ese" || f === "docs") && (c === "esedre" || c === "docs")) return true;
+  if ((f === "alce" || f === "web") && (c === "alce" || c === "web")) return true;
+  return false;
+}
+function writeSafeFile(filePath, content) {
+  const dir = path3.dirname(filePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  const normalized = content.replace(/\n/g, "\n");
+  const tempPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs3.writeFileSync(tempPath, normalized, "utf-8");
+    fs3.renameSync(tempPath, filePath);
+  } catch {
+    fs3.writeFileSync(filePath, normalized, "utf-8");
+    if (fs3.existsSync(tempPath)) {
+      try {
+        fs3.unlinkSync(tempPath);
+      } catch {
+      }
+    }
+  }
+}
+var FilesystemStorageAdapter = class {
+  workspaceRoot;
+  config;
+  constructor(workspaceRoot, config) {
+    this.workspaceRoot = workspaceRoot || this.resolveWorkspaceRoot();
+    if (config) {
+      this.config = config;
+    } else {
+      try {
+        const discovered = findEsedreConfig(this.workspaceRoot);
+        this.config = discovered.config || {};
+      } catch {
+        this.config = {};
+      }
+    }
+  }
+  resolveWorkspaceRoot() {
+    let current = process.cwd();
+    while (current !== path3.dirname(current)) {
+      const candidateConfig = path3.join(current, ".esedre", "esedre.json");
+      const candidateRootConfig = path3.join(current, "esedre.json");
+      const candidateTickets = path3.join(current, "src", "data", "planning", "tickets");
+      const candidateProjectsDir = path3.join(current, "src", "data", "planning", "projects", "projects.json");
+      const candidateProjects = path3.join(current, "src", "data", "planning", "projects.json");
+      if (fs3.existsSync(candidateConfig) || fs3.existsSync(candidateRootConfig) || fs3.existsSync(candidateTickets) || fs3.existsSync(candidateProjectsDir) || fs3.existsSync(candidateProjects)) {
+        return current;
+      }
+      current = path3.dirname(current);
+    }
+    return process.cwd();
+  }
+  resolveProjectLocations() {
+    const locations = [];
+    const seenCodes = /* @__PURE__ */ new Set();
+    const rawDataDirs = Array.isArray(this.config.dataDir) ? this.config.dataDir : this.config.dataDir ? [this.config.dataDir] : [];
+    for (const dDir of rawDataDirs) {
+      const resolvedHub = path3.resolve(this.workspaceRoot, dDir);
+      if (!fs3.existsSync(resolvedHub)) continue;
+      const projectsSubDir = path3.join(resolvedHub, "projects");
+      if (fs3.existsSync(projectsSubDir)) {
+        let entries = [];
+        try {
+          entries = fs3.readdirSync(projectsSubDir, { withFileTypes: true });
+        } catch {
+        }
+        for (const ent of entries) {
+          if (!ent.isDirectory()) continue;
+          const projectDir = path3.join(projectsSubDir, ent.name);
+          const projectTicketsDir = path3.join(projectDir, "tickets");
+          let desc;
+          const pJsonPath = path3.join(projectDir, "project.json");
+          if (fs3.existsSync(pJsonPath)) {
+            try {
+              desc = JSON.parse(fs3.readFileSync(pJsonPath, "utf-8"));
+            } catch {
+            }
+          }
+          if (!desc) {
+            const hubProjectsFile = path3.join(resolvedHub, "projects.json");
+            const subHubProjectsFile = path3.join(projectsSubDir, "projects.json");
+            for (const f of [hubProjectsFile, subHubProjectsFile]) {
+              if (fs3.existsSync(f)) {
+                try {
+                  const hubProjs = JSON.parse(fs3.readFileSync(f, "utf-8"));
+                  desc = hubProjs.find(
+                    (p) => p.code.toLowerCase() === ent.name.toLowerCase() || p.slug.toLowerCase() === ent.name.toLowerCase()
+                  );
+                  if (desc) break;
+                } catch {
+                }
+              }
+            }
+          }
+          if (!desc) {
+            desc = {
+              id: locations.length + 1,
+              code: ent.name,
+              slug: ent.name.toLowerCase(),
+              name: ent.name,
+              description: `${ent.name} project`
+            };
+          }
+          const codeKey = desc.code.toLowerCase();
+          if (!seenCodes.has(codeKey)) {
+            seenCodes.add(codeKey);
+            locations.push({
+              project: desc,
+              ticketsDir: projectTicketsDir,
+              sourceType: "hub",
+              hubDir: resolvedHub
+            });
+          }
+        }
+      } else {
+        const flatTicketsDir = path3.join(resolvedHub, "tickets");
+        const actualTicketsDir = fs3.existsSync(flatTicketsDir) ? flatTicketsDir : resolvedHub;
+        let descs = [];
+        const pJsonCandidates = [
+          path3.join(resolvedHub, "projects.json"),
+          path3.join(resolvedHub, "project.json")
+        ];
+        for (const cand of pJsonCandidates) {
+          if (fs3.existsSync(cand)) {
+            try {
+              const parsed = JSON.parse(fs3.readFileSync(cand, "utf-8"));
+              descs = Array.isArray(parsed) ? parsed : [parsed];
+              break;
+            } catch {
+            }
+          }
+        }
+        if (descs.length === 0) {
+          const pCode = this.config.projectCode || "CORE";
+          descs = [{
+            id: 1,
+            code: pCode,
+            slug: pCode.toLowerCase(),
+            name: pCode,
+            description: `${pCode} project`
+          }];
+        }
+        const isShared = descs.length > 1;
+        for (const desc of descs) {
+          const codeKey = desc.code.toLowerCase();
+          if (!seenCodes.has(codeKey)) {
+            seenCodes.add(codeKey);
+            locations.push({
+              project: desc,
+              ticketsDir: actualTicketsDir,
+              sourceType: "hub",
+              hubDir: resolvedHub,
+              isSharedDir: isShared
+            });
+          }
+        }
+      }
+    }
+    if (this.config.projects && typeof this.config.projects === "object") {
+      for (const [code, rawPath] of Object.entries(this.config.projects)) {
+        const projectDir = path3.resolve(this.workspaceRoot, rawPath);
+        if (!fs3.existsSync(projectDir)) continue;
+        let actualTicketsDir = path3.join(projectDir, "tickets");
+        if (fs3.existsSync(path3.join(projectDir, ".esedre", "tickets"))) {
+          actualTicketsDir = path3.join(projectDir, ".esedre", "tickets");
+        } else if (fs3.existsSync(path3.join(projectDir, "tickets"))) {
+          actualTicketsDir = path3.join(projectDir, "tickets");
+        } else if (fs3.existsSync(path3.join(projectDir, "src", "data", "planning", "tickets"))) {
+          actualTicketsDir = path3.join(projectDir, "src", "data", "planning", "tickets");
+        }
+        let desc;
+        const pJsonCandidates = [
+          path3.join(projectDir, ".esedre", "project.json"),
+          path3.join(projectDir, "project.json")
+        ];
+        for (const cand of pJsonCandidates) {
+          if (fs3.existsSync(cand)) {
+            try {
+              desc = JSON.parse(fs3.readFileSync(cand, "utf-8"));
+              break;
+            } catch {
+            }
+          }
+        }
+        if (!desc) {
+          desc = {
+            id: locations.length + 1,
+            code,
+            slug: code.toLowerCase(),
+            name: code,
+            description: `${code} project`
+          };
+        }
+        const codeKey = desc.code.toLowerCase();
+        if (!seenCodes.has(codeKey)) {
+          seenCodes.add(codeKey);
+          locations.push({
+            project: desc,
+            ticketsDir: actualTicketsDir,
+            sourceType: "federated"
+          });
+        }
+      }
+    }
+    if (locations.length === 0) {
+      const candidateDirs = [
+        path3.join(this.workspaceRoot, ".esedre", "tickets"),
+        path3.join(this.workspaceRoot, "tickets"),
+        path3.join(this.workspaceRoot, "src", "data", "planning", "tickets")
+      ];
+      const foundTicketsDir = candidateDirs.find((d) => fs3.existsSync(d)) || path3.join(this.workspaceRoot, ".esedre", "tickets");
+      let descs = [];
+      const pJsonCandidates = [
+        path3.join(this.workspaceRoot, ".esedre", "projects.json"),
+        path3.join(this.workspaceRoot, ".esedre", "project.json"),
+        path3.join(this.workspaceRoot, "projects.json"),
+        path3.join(this.workspaceRoot, "project.json"),
+        path3.join(this.workspaceRoot, "src", "data", "planning", "projects", "projects.json"),
+        path3.join(this.workspaceRoot, "src", "data", "planning", "projects.json")
+      ];
+      for (const cand of pJsonCandidates) {
+        if (fs3.existsSync(cand)) {
+          try {
+            const parsed = JSON.parse(fs3.readFileSync(cand, "utf-8"));
+            descs = Array.isArray(parsed) ? parsed : [parsed];
+            break;
+          } catch {
+          }
+        }
+      }
+      if (descs.length === 0) {
+        if (this.config.projectCode) {
+          const pName = this.config.projectName || this.config.projectCode;
+          descs = [{
+            id: 1,
+            code: this.config.projectCode,
+            slug: this.config.projectCode.toLowerCase(),
+            name: pName,
+            description: `${pName} project`
+          }];
+        } else {
+          return locations;
+        }
+      }
+      const isShared = descs.length > 1;
+      for (const desc of descs) {
+        const codeKey = desc.code.toLowerCase();
+        if (!seenCodes.has(codeKey)) {
+          seenCodes.add(codeKey);
+          locations.push({
+            project: desc,
+            ticketsDir: foundTicketsDir,
+            sourceType: "in-repo",
+            isSharedDir: isShared
+          });
+        }
+      }
+    }
+    return locations;
+  }
+  async getProjects() {
+    return this.resolveProjectLocations().map((l) => l.project);
+  }
+  async registerProject(input) {
+    const rawCode = input.code.trim();
+    const cleanCode = rawCode.toUpperCase();
+    const cleanName = input.name?.trim() || cleanCode;
+    const cleanDesc = input.description?.trim() || `${cleanName} project`;
+    const slug = cleanCode.toLowerCase();
+    const colors2 = input.colors || {
+      badge: "border-cyan-500/30 bg-cyan-500/10 text-cyan-300",
+      dot: "bg-cyan-400",
+      border: "border-cyan-500/40"
+    };
+    const rawDataDirs = Array.isArray(this.config.dataDir) ? this.config.dataDir : this.config.dataDir ? [this.config.dataDir] : [];
+    let targetHub = null;
+    for (const dDir of rawDataDirs) {
+      const resolved = path3.resolve(this.workspaceRoot, dDir);
+      if (fs3.existsSync(resolved)) {
+        targetHub = resolved;
+        break;
+      }
+    }
+    if (targetHub) {
+      const hubProjectsDir = path3.join(targetHub, "projects");
+      const projectDir = path3.join(hubProjectsDir, cleanCode);
+      const ticketsDir2 = path3.join(projectDir, "tickets");
+      if (!fs3.existsSync(ticketsDir2)) {
+        fs3.mkdirSync(ticketsDir2, { recursive: true });
+      }
+      const pJsonPath2 = path3.join(projectDir, "project.json");
+      let existingPJson2 = null;
+      if (fs3.existsSync(pJsonPath2)) {
+        try {
+          existingPJson2 = JSON.parse(fs3.readFileSync(pJsonPath2, "utf-8"));
+        } catch {
+        }
+      }
+      const id2 = existingPJson2?.id || (await this.getProjects()).length + 1;
+      const projectDesc2 = {
+        id: id2,
+        code: cleanCode,
+        slug,
+        name: cleanName,
+        description: cleanDesc,
+        colors: colors2
+      };
+      writeSafeFile(pJsonPath2, JSON.stringify(projectDesc2, null, 2) + "\n");
+      const hubProjectsFile = path3.join(targetHub, "projects.json");
+      if (fs3.existsSync(hubProjectsFile)) {
+        try {
+          const arr = JSON.parse(fs3.readFileSync(hubProjectsFile, "utf-8"));
+          const idx = arr.findIndex((p) => p.code.toLowerCase() === slug);
+          if (idx >= 0) {
+            arr[idx] = projectDesc2;
+          } else {
+            arr.push(projectDesc2);
+          }
+          writeSafeFile(hubProjectsFile, JSON.stringify(arr, null, 2) + "\n");
+        } catch {
+        }
+      }
+      return projectDesc2;
+    }
+    const esedreDir = path3.join(this.workspaceRoot, ".esedre");
+    const ticketsDir = path3.join(esedreDir, "tickets");
+    if (!fs3.existsSync(ticketsDir)) {
+      fs3.mkdirSync(ticketsDir, { recursive: true });
+    }
+    const pJsonPath = path3.join(esedreDir, "project.json");
+    let existingPJson = null;
+    if (fs3.existsSync(pJsonPath)) {
+      try {
+        existingPJson = JSON.parse(fs3.readFileSync(pJsonPath, "utf-8"));
+      } catch {
+      }
+    }
+    const id = existingPJson?.id || 1;
+    const projectDesc = {
+      id,
+      code: cleanCode,
+      slug,
+      name: cleanName,
+      description: cleanDesc,
+      colors: colors2
+    };
+    writeSafeFile(pJsonPath, JSON.stringify(projectDesc, null, 2) + "\n");
+    const projectsJsonPath = path3.join(esedreDir, "projects.json");
+    if (fs3.existsSync(projectsJsonPath)) {
+      try {
+        const arr = JSON.parse(fs3.readFileSync(projectsJsonPath, "utf-8"));
+        const idx = arr.findIndex((p) => p.code.toLowerCase() === slug);
+        if (idx >= 0) {
+          arr[idx] = projectDesc;
+        } else {
+          arr.push(projectDesc);
+        }
+        writeSafeFile(projectsJsonPath, JSON.stringify(arr, null, 2) + "\n");
+      } catch {
+      }
+    }
+    return projectDesc;
+  }
+  findTicketLocation(id) {
+    const locations = this.resolveProjectLocations();
+    if (locations.length === 0) return null;
+    const strId = String(id).trim();
+    const prefixMatch = strId.match(/^([a-zA-Z0-9]{1,6})[-_:](\d+)$/i);
+    if (prefixMatch) {
+      const code = prefixMatch[1].toLowerCase();
+      const num2 = parseInt(prefixMatch[2], 10);
+      const loc = locations.find((l) => isProjectMatch(l.project.code, l.project.slug, code));
+      if (!loc) return null;
+      const ticketDir = path3.join(loc.ticketsDir, String(num2));
+      const metaPath = path3.join(ticketDir, "meta.json");
+      if (fs3.existsSync(metaPath)) {
+        if (loc.isSharedDir) {
+          try {
+            const metaRaw = fs3.readFileSync(metaPath, "utf-8");
+            const meta = JSON.parse(metaRaw);
+            meta.type = meta.type || meta.category || "Feature";
+            meta.category = meta.type;
+            const mProj = (meta.project || "").toLowerCase();
+            if (mProj && mProj !== code && mProj !== loc.project.slug.toLowerCase()) {
+              return null;
+            }
+          } catch {
+          }
+        }
+        return { loc, ticketDir, id: num2 };
+      }
+      return null;
+    }
+    const num = typeof id === "number" ? id : parseInt(strId, 10);
+    if (isNaN(num)) return null;
+    const matches = [];
+    const checkedDirs = /* @__PURE__ */ new Set();
+    for (const loc of locations) {
+      const ticketDir = path3.join(loc.ticketsDir, String(num));
+      const metaPath = path3.join(ticketDir, "meta.json");
+      if (!fs3.existsSync(metaPath)) continue;
+      if (loc.isSharedDir) {
+        if (checkedDirs.has(ticketDir)) continue;
+        checkedDirs.add(ticketDir);
+        try {
+          const metaRaw = fs3.readFileSync(metaPath, "utf-8");
+          const meta = JSON.parse(metaRaw);
+          const matchedLoc = locations.find(
+            (l) => meta.projectId !== void 0 && l.project.id === meta.projectId || meta.project && (l.project.code.toLowerCase() === meta.project.toLowerCase() || l.project.slug.toLowerCase() === meta.project.toLowerCase())
+          ) || loc;
+          matches.push({ loc: matchedLoc, ticketDir, id: num });
+        } catch {
+          matches.push({ loc, ticketDir, id: num });
+        }
+      } else {
+        matches.push({ loc, ticketDir, id: num });
+      }
+    }
+    if (this.config.projectCode) {
+      const prefLower = this.config.projectCode.toLowerCase();
+      const preferredMatch = matches.find(
+        (m) => m.loc.project.code.toLowerCase() === prefLower || m.loc.project.slug.toLowerCase() === prefLower
+      );
+      if (preferredMatch) return preferredMatch;
+    }
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    if (matches.length > 1) {
+      const codes = matches.map((m) => m.loc.project.code);
+      throw new Error(
+        `Ambiguous ticket #${num}: exists in multiple projects (${codes.join(", ")}). Please specify as <ProjectCode>-${num} (e.g. ${codes[0]}-${num}).`
+      );
+    }
+    return null;
+  }
+  async listTickets(filter) {
+    const locations = this.resolveProjectLocations();
+    const tickets = [];
+    const processedSharedTickets = /* @__PURE__ */ new Set();
+    for (const loc of locations) {
+      if (filter?.project && filter.project !== "all") {
+        const pLower = filter.project.toLowerCase();
+        if (!isProjectMatch(loc.project.code, loc.project.slug, filter.project)) {
+          continue;
+        }
+      }
+      if (!fs3.existsSync(loc.ticketsDir)) continue;
+      let entries = [];
+      try {
+        entries = fs3.readdirSync(loc.ticketsDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const num = parseInt(entry.name, 10);
+        if (isNaN(num)) continue;
+        const ticketDir = path3.join(loc.ticketsDir, entry.name);
+        const metaPath = path3.join(ticketDir, "meta.json");
+        if (!fs3.existsSync(metaPath)) continue;
+        if (loc.isSharedDir) {
+          const key = `${loc.ticketsDir}:${entry.name}`;
+          if (processedSharedTickets.has(key)) continue;
+          processedSharedTickets.add(key);
+        }
+        try {
+          const metaRaw = fs3.readFileSync(metaPath, "utf-8");
+          const meta = JSON.parse(metaRaw);
+          meta.id = meta.id ?? num;
+          meta.type = meta.type || meta.category || "Feature";
+          meta.category = meta.type;
+          let effectiveLoc = loc;
+          if (loc.isSharedDir) {
+            const found = locations.find(
+              (l) => meta.projectId !== void 0 && l.project.id === meta.projectId || meta.project && (l.project.code.toLowerCase() === meta.project.toLowerCase() || l.project.slug.toLowerCase() === meta.project.toLowerCase())
+            );
+            if (found) effectiveLoc = found;
+          }
+          meta.project = effectiveLoc.project.code;
+          meta.projectId = effectiveLoc.project.id;
+          if (filter?.project && filter.project !== "all") {
+            const pLower = filter.project.toLowerCase();
+            if (!isProjectMatch(meta.project, effectiveLoc.project.slug, filter.project)) {
+              continue;
+            }
+          }
+          if (filter?.status && meta.status !== filter.status) {
+            continue;
+          }
+          if (filter?.category && meta.category !== filter.category) {
+            continue;
+          }
+          if (filter?.search) {
+            const term = filter.search.toLowerCase();
+            const matchesTitle = meta.title.toLowerCase().includes(term);
+            const matchesNum = String(meta.id).includes(term) || `${meta.project}-${meta.id}`.toLowerCase().includes(term);
+            if (!matchesTitle && !matchesNum) {
+              continue;
+            }
+          }
+          let detail;
+          const detailPath = path3.join(ticketDir, "detail.md");
+          if (fs3.existsSync(detailPath)) {
+            const raw = fs3.readFileSync(detailPath, "utf-8");
+            detail = this.parseDetailMarkdown(raw);
+          }
+          let planMarkdown;
+          const planPath = path3.join(ticketDir, "implementation_plan.md");
+          if (fs3.existsSync(planPath)) {
+            planMarkdown = fs3.readFileSync(planPath, "utf-8");
+          }
+          let comments = [];
+          const commentsPath = path3.join(ticketDir, "comments.json");
+          if (fs3.existsSync(commentsPath)) {
+            try {
+              comments = JSON.parse(fs3.readFileSync(commentsPath, "utf-8"));
+            } catch {
+            }
+          }
+          const ticketObj = {
+            meta,
+            detail,
+            planMarkdown,
+            comments,
+            projectDescriptor: effectiveLoc.project
+          };
+          ticketObj.sha1 = computeTicketHash(ticketObj);
+          ticketObj.lastHash = ticketObj.sha1;
+          tickets.push(ticketObj);
+        } catch {
+        }
+      }
+    }
+    return tickets.sort((a, b) => {
+      if (a.meta.project !== b.meta.project) {
+        return (a.meta.project || "").localeCompare(b.meta.project || "");
+      }
+      return a.meta.id - b.meta.id;
+    });
+  }
+  async getTicket(id) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) return null;
+    const metaPath = path3.join(locInfo.ticketDir, "meta.json");
+    if (!fs3.existsSync(metaPath)) return null;
+    try {
+      const metaRaw = fs3.readFileSync(metaPath, "utf-8");
+      const meta = JSON.parse(metaRaw);
+      meta.id = meta.id ?? locInfo.id;
+      meta.project = locInfo.loc.project.code;
+      meta.projectId = locInfo.loc.project.id;
+      let detail;
+      const detailPath = path3.join(locInfo.ticketDir, "detail.md");
+      if (fs3.existsSync(detailPath)) {
+        const raw = fs3.readFileSync(detailPath, "utf-8");
+        detail = this.parseDetailMarkdown(raw);
+      }
+      let planMarkdown;
+      const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
+      if (fs3.existsSync(planPath)) {
+        planMarkdown = fs3.readFileSync(planPath, "utf-8");
+      }
+      let comments = [];
+      const commentsPath = path3.join(locInfo.ticketDir, "comments.json");
+      if (fs3.existsSync(commentsPath)) {
+        try {
+          comments = JSON.parse(fs3.readFileSync(commentsPath, "utf-8"));
+        } catch {
+        }
+      }
+      const ticket = {
+        meta,
+        detail,
+        planMarkdown,
+        comments,
+        projectDescriptor: locInfo.loc.project
+      };
+      ticket.sha1 = computeTicketHash(ticket);
+      ticket.lastHash = ticket.sha1;
+      return ticket;
+    } catch {
+      return null;
+    }
+  }
+  parseDetailMarkdown(raw) {
+    const titleMatch = raw.match(/^#\s*(?:Ticket\s*#?\d+\s*:\s*|\d+\s*:\s*)?([^\n]+)/im);
+    const title = titleMatch ? titleMatch[1].trim() : "Untitled Ticket";
+    const typeMatch = raw.match(/\*\*(?:Type|Category)\*\*:\s*([^\n]+)/i);
+    const type = typeMatch ? typeMatch[1].trim() : "Feature";
+    const category = type;
+    const complexityMatch = raw.match(/\*\*Complexity\*\*:\s*([^\n]+)/i);
+    const complexity = complexityMatch ? complexityMatch[1].trim() : "Medium";
+    const effortMatch = raw.match(/\*\*Estimated Effort\*\*:\s*([^\n]+)/i);
+    const estimatedEffort = effortMatch ? effortMatch[1].trim() : "2.0 - 4.0 hours";
+    let summary;
+    const summaryMatch = raw.match(/(?:##|###)\s*(?:Summary|Rationale)\s*\n([\s\S]*?)(?=\n##|\n###|\n#|$)/i);
+    if (summaryMatch) {
+      summary = summaryMatch[1].trim();
+    }
+    const breakdown = [];
+    const breakdownMatch = raw.match(/(?:##|###)\s*Feature Breakdown\s*\n([\s\S]*?)(?=\n##|\n###|\n#|$)/i);
+    if (breakdownMatch) {
+      const lines = breakdownMatch[1].split("\n");
+      for (const line of lines) {
+        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-)\s+(.*)/);
+        if (itemMatch) breakdown.push(itemMatch[1].trim());
+      }
+    }
+    const technicalDetails = [];
+    const techMatch = raw.match(/###\s*(?:Technical Details?|Architecture)\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|$)/i);
+    if (techMatch) {
+      const lines = techMatch[1].split("\n");
+      for (const line of lines) {
+        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-)\s+(.*)/);
+        if (itemMatch) technicalDetails.push(itemMatch[1].trim());
+      }
+    }
+    const openQuestions = [];
+    const questionsMatch = raw.match(/###\s*(?:Open Questions?|Technical Detail & Open Questions?|Decisions)\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|$)/i);
+    if (questionsMatch) {
+      const lines = questionsMatch[1].split("\n");
+      for (const line of lines) {
+        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-)\s+(.*)/);
+        if (itemMatch) openQuestions.push(itemMatch[1].trim());
+      }
+    }
+    return {
+      title,
+      type,
+      category,
+      complexity,
+      estimatedEffort,
+      summary,
+      breakdown,
+      technicalDetails,
+      openQuestions,
+      raw
+    };
+  }
+  async createTicket(input) {
+    const locations = this.resolveProjectLocations();
+    if (locations.length === 0) {
+      throw new Error("No projects registered in workspace. Please configure projects before creating tickets.");
+    }
+    const requestedIdentifier = input.projectCode || input.projectId || this.config.projectCode;
+    let targetLoc;
+    if (requestedIdentifier) {
+      const lower = String(requestedIdentifier).trim().toLowerCase();
+      targetLoc = locations.find(
+        (l) => l.project.code.toLowerCase() === lower || l.project.slug.toLowerCase() === lower || String(l.project.id) === lower || l.project.name.toLowerCase() === lower
+      );
+      if (!targetLoc) {
+        throw new Error(`Project '${requestedIdentifier}' is invalid or not registered in this workspace.`);
+      }
+    } else if (locations.length === 1) {
+      targetLoc = locations[0];
+    } else {
+      const availableCodes = locations.map((l) => l.project.code).join(", ");
+      throw new Error(`Project is required to create a ticket (available: ${availableCodes}).`);
+    }
+    if (!fs3.existsSync(targetLoc.ticketsDir)) {
+      fs3.mkdirSync(targetLoc.ticketsDir, { recursive: true });
+    }
+    const existing = fs3.readdirSync(targetLoc.ticketsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !isNaN(parseInt(d.name, 10))).map((d) => parseInt(d.name, 10));
+    const nextId = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+    const ticketDir = path3.join(targetLoc.ticketsDir, String(nextId));
+    fs3.mkdirSync(ticketDir, { recursive: true });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const effectiveType = input.type || input.category || "Feature";
+    const meta = {
+      id: nextId,
+      title: input.title.slice(0, 48).trim(),
+      type: effectiveType,
+      category: effectiveType,
+      complexity: input.complexity || "Medium",
+      estimatedEffort: input.estimatedEffort || input.effort || "2.0 - 4.0 hours",
+      submittedBy: input.submittedBy || "Developer",
+      timestamp: now,
+      createdAt: now,
+      updatedAt: now,
+      revision: 1,
+      isActivePlanning: false,
+      status: "Planned",
+      projectId: targetLoc.project.id,
+      project: targetLoc.project.code
+    };
+    const detailMd = `# Ticket #${nextId}: ${meta.title}
+**Category**: ${meta.category}  
+**Complexity**: ${meta.complexity}  
+**Estimated Effort**: ${meta.estimatedEffort}  
+
+### Summary
+${input.summary || "Summary to be defined."}
+
+### Feature Breakdown
+1. **Initial Requirement**:
+   - Details to be populated during planning.
+
+### Technical Details & Architecture
+- Architecture specifications to be documented.
+
+### Open Questions & Decisions
+- None recorded at initialization.
+`;
+    writeSafeFile(path3.join(ticketDir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+    writeSafeFile(path3.join(ticketDir, "detail.md"), detailMd);
+    const created = await this.getTicket(`${targetLoc.project.code}-${nextId}`);
+    return created;
+  }
+  async updateTicket(id, updates, lastHash) {
+    const existing = await this.getTicket(id);
+    if (!existing) {
+      throw new Error(`Ticket #${id} does not exist`);
+    }
+    if (lastHash !== void 0) {
+      const currentHash = existing.sha1 || computeTicketHash(existing);
+      if (!verifyTicketHash(currentHash, lastHash)) {
+        throw new EsedreConflictError(id, currentHash, lastHash);
+      }
+    }
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const metaPath = path3.join(locInfo.ticketDir, "meta.json");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const isNowCompleted = updates.status === "Completed";
+    const completedAt = isNowCompleted ? existing.meta.completedAt || now : updates.status && updates.status !== "Completed" ? void 0 : existing.meta.completedAt;
+    const revision = (existing.meta.revision || 1) + 1;
+    const updatedMeta = {
+      ...existing.meta,
+      ...updates,
+      id: locInfo.id,
+      updatedAt: now,
+      completedAt,
+      revision
+    };
+    writeSafeFile(metaPath, JSON.stringify(updatedMeta, null, 2) + "\n");
+    const newType = updates.type || updates.category;
+    if (newType) {
+      updatedMeta.type = newType;
+      updatedMeta.category = newType;
+    }
+    if (existing.detail && (updates.title || updates.type || updates.category || updates.complexity || updates.estimatedEffort)) {
+      let content = existing.detail.raw;
+      if (updates.title) {
+        content = content.replace(/^#\s*(?:Ticket\s*#?\d+\s*:\s*|\d+\s*:\s*)?[^\n]+/im, `# Ticket #${locInfo.id}: ${updatedMeta.title}`);
+      }
+      if (updates.type || updates.category) {
+        content = content.replace(/\*\*(?:Type|Category)\*\*:\s*[^\n]+/i, `**Type**: ${updatedMeta.type}`);
+      }
+      if (updates.complexity) {
+        content = content.replace(/\*\*Complexity\*\*:\s*[^\n]+/i, `**Complexity**: ${updatedMeta.complexity}`);
+      }
+      if (updates.estimatedEffort) {
+        content = content.replace(/\*\*Estimated Effort\*\*:\s*[^\n]+/i, `**Estimated Effort**: ${updatedMeta.estimatedEffort}`);
+      }
+      writeSafeFile(path3.join(locInfo.ticketDir, "detail.md"), content);
+    }
+    return await this.getTicket(`${locInfo.loc.project.code}-${locInfo.id}`);
+  }
+  async getPlan(id) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) return null;
+    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
+    if (!fs3.existsSync(planPath)) return null;
+    return fs3.readFileSync(planPath, "utf-8");
+  }
+  async savePlan(id, planMarkdown, lastHash) {
+    const ticket = await this.getTicket(id);
+    if (!ticket) {
+      throw new Error(`Ticket #${id} does not exist`);
+    }
+    if (lastHash !== void 0) {
+      const currentHash = ticket.sha1 || computeTicketHash(ticket);
+      if (!verifyTicketHash(currentHash, lastHash)) {
+        throw new EsedreConflictError(id, currentHash, lastHash);
+      }
+    }
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
+    writeSafeFile(planPath, planMarkdown);
+    const metaPath = path3.join(locInfo.ticketDir, "meta.json");
+    if (fs3.existsSync(metaPath)) {
+      try {
+        const meta = JSON.parse(fs3.readFileSync(metaPath, "utf-8"));
+        meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        meta.revision = (meta.revision || 1) + 1;
+        writeSafeFile(metaPath, JSON.stringify(meta, null, 2) + "\n");
+      } catch {
+      }
+    }
+  }
+  async addComment(id, comment) {
+    const ticket = await this.getTicket(id);
+    if (!ticket) {
+      throw new Error(`Ticket #${id} does not exist`);
+    }
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const commentsPath = path3.join(locInfo.ticketDir, "comments.json");
+    let comments = [];
+    if (fs3.existsSync(commentsPath)) {
+      try {
+        comments = JSON.parse(fs3.readFileSync(commentsPath, "utf-8"));
+      } catch {
+      }
+    }
+    const newComment = {
+      id: `${locInfo.id}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      author: comment.author || "User",
+      text: comment.text.trim()
+    };
+    comments.push(newComment);
+    writeSafeFile(commentsPath, JSON.stringify(comments, null, 2) + "\n");
+    return newComment;
+  }
+};
+
+// src/securityFilter.ts
+var SecurityFilter = class {
+  constructor(target, config = {}) {
+    this.target = target;
+    this.config = config;
+  }
+  target;
+  config;
+  async getProjects() {
+    const projs = await this.target.getProjects();
+    if (!this.config.allowedProjects || this.config.allowedProjects.length === 0) {
+      return projs;
+    }
+    return projs.filter((p) => isProjectAuthorized(p.code, this.config.allowedProjects));
+  }
+  async registerProject(input) {
+    const proj = await this.target.registerProject(input);
+    if (this.config.allowedProjects && !this.config.allowedProjects.includes("*")) {
+      const upper = proj.code.toUpperCase();
+      if (!this.config.allowedProjects.some((p) => p.toUpperCase() === upper)) {
+        this.config.allowedProjects.push(proj.code);
+      }
+    }
+    return proj;
+  }
+  async listTickets(filter) {
+    if (filter?.project && !isProjectAuthorized(filter.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(filter.project);
+    }
+    const tickets = await this.target.listTickets(filter);
+    if (!this.config.allowedProjects || this.config.allowedProjects.length === 0) {
+      return tickets;
+    }
+    return tickets.filter((t) => {
+      const code = t.projectDescriptor?.code || t.meta.project;
+      if (!code) return true;
+      return isProjectAuthorized(code, this.config.allowedProjects);
+    });
+  }
+  async getTicket(id) {
+    const ticket = await this.target.getTicket(id);
+    if (!ticket) return null;
+    const code = ticket.projectDescriptor?.code || ticket.meta.project;
+    if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(code);
+    }
+    return ticket;
+  }
+  async createTicket(input) {
+    const targetCode = input.projectCode || this.config.projectCode;
+    if (targetCode && !isProjectAuthorized(targetCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(targetCode);
+    }
+    return this.target.createTicket(input);
+  }
+  async updateTicket(id, updates, lastHash) {
+    const existing = await this.target.getTicket(id);
+    if (existing) {
+      const code = existing.projectDescriptor?.code || existing.meta.project;
+      if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(code);
+      }
+    }
+    if (updates.project && !isProjectAuthorized(updates.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(updates.project);
+    }
+    return this.target.updateTicket(id, updates, lastHash);
+  }
+  async getPlan(id) {
+    const ticket = await this.target.getTicket(id);
+    if (ticket) {
+      const code = ticket.projectDescriptor?.code || ticket.meta.project;
+      if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(code);
+      }
+    }
+    return this.target.getPlan(id);
+  }
+  async savePlan(id, planMarkdown, lastHash) {
+    const ticket = await this.target.getTicket(id);
+    if (ticket) {
+      const code = ticket.projectDescriptor?.code || ticket.meta.project;
+      if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(code);
+      }
+    }
+    return this.target.savePlan(id, planMarkdown, lastHash);
+  }
+  async addComment(id, comment) {
+    const ticket = await this.target.getTicket(id);
+    if (ticket) {
+      const code = ticket.projectDescriptor?.code || ticket.meta.project;
+      if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(code);
+      }
+    }
+    return this.target.addComment(id, comment);
+  }
+};
+
+// src/utils/formatter.ts
+var isColorSupported = !process.env.NO_COLOR && (process.stdout.isTTY || process.env.FORCE_COLOR);
+var colors = {
+  reset: isColorSupported ? "\x1B[0m" : "",
+  bold: isColorSupported ? "\x1B[1m" : "",
+  dim: isColorSupported ? "\x1B[2m" : "",
+  cyan: isColorSupported ? "\x1B[36m" : "",
+  green: isColorSupported ? "\x1B[32m" : "",
+  yellow: isColorSupported ? "\x1B[33m" : "",
+  magenta: isColorSupported ? "\x1B[35m" : "",
+  red: isColorSupported ? "\x1B[31m" : "",
+  blue: isColorSupported ? "\x1B[34m" : ""
+};
+function formatTicketListTable(tickets) {
+  if (tickets.length === 0) {
+    return `${colors.dim}No tickets found matching criteria.${colors.reset}`;
+  }
+  const rows = tickets.map((t) => {
+    const id = t.projectDescriptor?.code ? `${t.projectDescriptor.code}-${t.meta.id}` : `#${t.meta.id}`;
+    const project = t.projectDescriptor?.code || "CORE";
+    const category = t.meta.category;
+    const status = t.meta.status;
+    const title = t.meta.title;
+    return { id, project, category, status, title };
+  });
+  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
+  const projWidth = Math.max(7, ...rows.map((r) => r.project.length));
+  const catWidth = Math.max(8, ...rows.map((r) => r.category.length));
+  const statusWidth = Math.max(14, ...rows.map((r) => r.status.length));
+  const header = `${colors.bold}${pad("ID", idWidth)}  ${pad("Project", projWidth)}  ${pad("Category", catWidth)}  ${pad("Status", statusWidth)}  Title${colors.reset}`;
+  const divider = `${colors.dim}${"-".repeat(idWidth)}  ${"-".repeat(projWidth)}  ${"-".repeat(catWidth)}  ${"-".repeat(statusWidth)}  ${"-".repeat(40)}${colors.reset}`;
+  const formattedRows = rows.map((r) => {
+    const statusColored = colorStatus(r.status);
+    const catColored = colorCategory(r.category);
+    const projColored = `${colors.magenta}${r.project}${colors.reset}`;
+    return `${colors.bold}${pad(r.id, idWidth)}${colors.reset}  ${pad(projColored, projWidth + (isColorSupported ? colors.magenta.length + colors.reset.length : 0))}  ${pad(catColored, catWidth + (isColorSupported ? 9 : 0))}  ${pad(statusColored, statusWidth + (isColorSupported ? 9 : 0))}  ${r.title}`;
+  });
+  return [header, divider, ...formattedRows].join("\n");
+}
+function formatTicketDetail(ticket) {
+  const { meta, detail, comments, planMarkdown, projectDescriptor } = ticket;
+  const lines = [];
+  lines.push(`${colors.bold}${colors.cyan}Ticket #${meta.project ? `${meta.project}-${meta.id}` : meta.id}: ${meta.title}${colors.reset}`);
+  lines.push(`${colors.dim}${"=".repeat(60)}${colors.reset}`);
+  lines.push(`${colors.bold}Project:${colors.reset}     ${projectDescriptor ? `${projectDescriptor.code} - ${projectDescriptor.name}` : "Default"}`);
+  lines.push(`${colors.bold}Category:${colors.reset}    ${colorCategory(meta.category)}`);
+  lines.push(`${colors.bold}Status:${colors.reset}      ${colorStatus(meta.status)}`);
+  lines.push(`${colors.bold}Complexity:${colors.reset}  ${meta.complexity || "Medium"}`);
+  lines.push(`${colors.bold}Effort:${colors.reset}      ${meta.estimatedEffort || "N/A"}`);
+  lines.push(`${colors.bold}Submitted By:${colors.reset} ${meta.submittedBy || "Unknown"}`);
+  if (meta.featureFlag) {
+    lines.push(`${colors.bold}Feature Flag:${colors.reset} ${colors.yellow}${meta.featureFlag}${colors.reset}`);
+  }
+  if (detail?.summary) {
+    lines.push("");
+    lines.push(`${colors.bold}Summary:${colors.reset}`);
+    lines.push(detail.summary);
+  }
+  if (detail?.breakdown && detail.breakdown.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Feature Breakdown:${colors.reset}`);
+    for (const b of detail.breakdown) {
+      lines.push(`  \u2022 ${b}`);
+    }
+  }
+  if (detail?.technicalDetails && detail.technicalDetails.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Technical Details:${colors.reset}`);
+    for (const t of detail.technicalDetails) {
+      lines.push(`  \u2022 ${t}`);
+    }
+  }
+  if (detail?.openQuestions && detail.openQuestions.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Open Decisions & Questions:${colors.reset}`);
+    for (const q of detail.openQuestions) {
+      lines.push(`  \u2022 ${q}`);
+    }
+  }
+  lines.push("");
+  lines.push(`${colors.bold}Implementation Plan:${colors.reset} ${planMarkdown ? `${colors.green}Available (${planMarkdown.split("\n").length} lines)${colors.reset}` : `${colors.dim}None recorded${colors.reset}`}`);
+  if (comments.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Comments (${comments.length}):${colors.reset}`);
+    for (const c of comments) {
+      lines.push(`  ${colors.dim}[${c.timestamp.slice(0, 10)}]${colors.reset} ${colors.bold}${c.author}:${colors.reset} ${c.text}`);
+    }
+  }
+  return lines.join("\n");
+}
+function pad(str, width) {
+  return str.padEnd(width, " ");
+}
+function colorStatus(status) {
+  switch (status) {
+    case "Completed":
+      return `${colors.green}${status}${colors.reset}`;
+    case "In Development":
+      return `${colors.green}${status}${colors.reset}`;
+    case "Rejected":
+      return `${colors.red}${status}${colors.reset}`;
+    default:
+      return `${colors.cyan}${status}${colors.reset}`;
+  }
+}
+function colorCategory(category) {
+  switch (category) {
+    case "Feature":
+      return `${colors.blue}${category}${colors.reset}`;
+    case "Platform":
+      return `${colors.magenta}${category}${colors.reset}`;
+    case "Tools":
+      return `${colors.yellow}${category}${colors.reset}`;
+    case "Bug":
+      return `${colors.red}${category}${colors.reset}`;
+    case "Idea":
+      return `${colors.green}${category}${colors.reset}`;
+    default:
+      return category;
+  }
+}
+
+// src/mcp/server.ts
+import readline from "node:readline";
+var EsedreMcpServer = class {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  start() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    process.stderr.write("[Esedre MCP Server] Initialized. Awaiting JSON-RPC messages on stdin...\n");
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const req = JSON.parse(trimmed);
+        const res = await this.handleRequest(req);
+        if (res && req.id !== void 0 && req.id !== null) {
+          process.stdout.write(JSON.stringify(res) + "\n");
+        }
+      } catch (err) {
+        process.stderr.write(`[Esedre MCP Error] Failed to parse or process line: ${err.message}
+`);
+        const errorRes = {
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "Parse error: " + err.message }
+        };
+        process.stdout.write(JSON.stringify(errorRes) + "\n");
+      }
+    });
+    rl.on("close", () => {
+      process.stderr.write("[Esedre MCP Server] Stdio closed. Exiting.\n");
+      process.exit(0);
+    });
+  }
+  async handleRequest(req) {
+    const id = req.id ?? null;
+    switch (req.method) {
+      case "initialize": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {},
+              resources: {}
+            },
+            serverInfo: {
+              name: "esedre",
+              version: "0.1.0"
+            }
+          }
+        };
+      }
+      case "notifications/initialized": {
+        return null;
+      }
+      case "ping": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {}
+        };
+      }
+      case "tools/list": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: this.getToolDefinitions()
+          }
+        };
+      }
+      case "tools/call": {
+        const toolName = req.params?.name;
+        const args = req.params?.arguments || {};
+        try {
+          const content = await this.executeTool(toolName, args);
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+                }
+              ]
+            }
+          };
+        } catch (err) {
+          if (err instanceof EsedreConflictError || err.name === "EsedreConflictError") {
+            return {
+              jsonrpc: "2.0",
+              id,
+              error: {
+                code: -32e3,
+                message: err.message,
+                data: {
+                  ticketId: err.ticketId,
+                  currentHash: err.currentHash,
+                  lastHash: err.lastHash
+                }
+              }
+            };
+          }
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32603,
+              message: `Error executing ${toolName}: ${err.message}`
+            }
+          };
+        }
+      }
+      case "resources/list": {
+        const tickets = await this.storage.listTickets();
+        const resources = tickets.map((t) => ({
+          uri: `esedre://tickets/${t.meta.id}`,
+          name: `Ticket #${t.meta.id}: ${t.meta.title}`,
+          description: `[${t.projectDescriptor?.code || t.meta.project || "UNASSIGNED"}] ${t.meta.type || t.meta.category} : ${t.meta.status}`,
+          mimeType: "text/markdown"
+        }));
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: { resources }
+        };
+      }
+      case "resources/read": {
+        const uri = req.params?.uri;
+        if (!uri) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Resource URI is required" }
+          };
+        }
+        try {
+          const match = uri.match(/^esedre:\/\/tickets\/([a-zA-Z0-9_-]+)$/);
+          if (match) {
+            const ticketId = match[1];
+            const ticket = await this.storage.getTicket(ticketId);
+            if (!ticket) {
+              return {
+                jsonrpc: "2.0",
+                id,
+                error: { code: -32602, message: `Ticket #${ticketId} not found` }
+              };
+            }
+            const markdown = ticket.detail?.raw || `# Ticket #${ticket.meta.id}: ${ticket.meta.title}
+
+Status: ${ticket.meta.status}`;
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {
+                contents: [
+                  {
+                    uri,
+                    mimeType: "text/markdown",
+                    text: markdown
+                  }
+                ]
+              }
+            };
+          }
+        } catch (err) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32603, message: err.message }
+          };
+        }
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32602, message: `Unsupported URI scheme: ${uri}` }
+        };
+      }
+      default: {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${req.method}`
+          }
+        };
+      }
+    }
+  }
+  getToolDefinitions() {
+    return [
+      {
+        name: "esedre_list_tickets",
+        description: "List roadmap tickets with optional project code, status, category, or search query.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Project code (e.g. CORE, WEB, DOCS)" },
+            status: { type: "string", enum: ["Planned", "In Development", "Completed", "Rejected"], description: "Ticket status" },
+            category: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"], description: "Ticket category" },
+            search: { type: "string", description: "Search keywords in title or ID" }
+          }
+        }
+      },
+      {
+        name: "esedre_get_ticket",
+        description: "Retrieve full details for a ticket including metadata, summary, feature breakdown, open decisions, and comments.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: "integer", description: "Numeric ticket ID (e.g. 96, 101)" }
+          },
+          required: ["ticketId"]
+        }
+      },
+      {
+        name: "esedre_get_plan",
+        description: "Retrieve the active implementation plan markdown for a ticket.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: "integer", description: "Numeric ticket ID" }
+          },
+          required: ["ticketId"]
+        }
+      },
+      {
+        name: "esedre_save_plan",
+        description: "Save or update the implementation plan markdown for a ticket.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: "integer", description: "Numeric ticket ID" },
+            planMarkdown: { type: "string", description: "Implementation plan markdown content" },
+            lastHash: { type: "string", description: "Optimistic concurrency control: last known sha1 hash of the ticket" }
+          },
+          required: ["ticketId", "planMarkdown"]
+        }
+      },
+      {
+        name: "esedre_create_ticket",
+        description: "Create a new roadmap ticket in Esedre.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Ticket title (max 48 characters)" },
+            project: { type: "string", description: "Target project code (e.g. CORE, WEB, DOCS)" },
+            category: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"], description: "Ticket category" },
+            complexity: { type: "string", description: "Complexity (e.g. Low, Medium, High)" },
+            effort: { type: "string", description: "Estimated effort (e.g. 2.0 \u2013 4.0 hours)" },
+            summary: { type: "string", description: "Initial feature summary" },
+            author: { type: "string", description: "Submitting author name" }
+          },
+          required: ["title", "category"]
+        }
+      },
+      {
+        name: "esedre_update_ticket",
+        description: "Update an existing ticket state (status, title, active planning flag, or feature flag).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: "integer", description: "Numeric ticket ID" },
+            status: { type: "string", enum: ["Planned", "In Development", "Completed", "Rejected"] },
+            title: { type: "string", description: "New title (max 48 characters)" },
+            inDevelopment: { type: "boolean", description: "Active development toggle" },
+            featureFlag: { type: "string", description: "Feature flag name" },
+            lastHash: { type: "string", description: "Optimistic concurrency control: last known sha1 hash of the ticket" }
+          },
+          required: ["ticketId"]
+        }
+      },
+      {
+        name: "esedre_add_comment",
+        description: "Append a developer or companion agent comment to a ticket.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: "integer", description: "Numeric ticket ID" },
+            text: { type: "string", description: "Comment message" },
+            author: { type: "string", description: "Author name (e.g. Antigravity, Developer)" }
+          },
+          required: ["ticketId", "text"]
+        }
+      }
+    ];
+  }
+  async executeTool(name, args) {
+    const canonical = name.replace(/^esedre_/, "");
+    switch (canonical) {
+      case "list_tickets": {
+        const tickets = await this.storage.listTickets({
+          project: args.project,
+          status: args.status,
+          category: args.category,
+          search: args.search
+        });
+        return tickets.map((t) => ({
+          id: t.meta.id,
+          title: t.meta.title,
+          category: t.meta.category,
+          status: t.meta.status,
+          complexity: t.meta.complexity,
+          effort: t.meta.estimatedEffort,
+          project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
+          sha1: t.sha1 || t.meta.sha1
+        }));
+      }
+      case "get_ticket": {
+        const id = parseInt(String(args.ticketId), 10);
+        const ticket = await this.storage.getTicket(id);
+        if (!ticket) throw new Error(`Ticket #${id} not found`);
+        return ticket;
+      }
+      case "get_plan": {
+        const id = parseInt(String(args.ticketId), 10);
+        const plan = await this.storage.getPlan(id);
+        return { ticketId: id, planMarkdown: plan || null };
+      }
+      case "save_plan": {
+        const id = parseInt(String(args.ticketId), 10);
+        await this.storage.savePlan(id, args.planMarkdown, args.lastHash);
+        return { success: true, message: `Implementation plan saved for Ticket #${id}` };
+      }
+      case "create_ticket": {
+        const created = await this.storage.createTicket({
+          title: args.title,
+          type: args.type || args.category,
+          category: args.type || args.category,
+          projectCode: args.project,
+          complexity: args.complexity,
+          estimatedEffort: args.effort,
+          summary: args.summary,
+          submittedBy: args.author || "Agent"
+        });
+        return created;
+      }
+      case "update_ticket": {
+        const id = parseInt(String(args.ticketId), 10);
+        const updates = {};
+        if (args.status) updates.status = args.status;
+        if (args.title) updates.title = args.title;
+        if (args.inDevelopment !== void 0) updates.isActivePlanning = Boolean(args.inDevelopment);
+        if (args.featureFlag) updates.featureFlag = args.featureFlag;
+        const updated = await this.storage.updateTicket(id, updates, args.lastHash);
+        return updated;
+      }
+      case "add_comment": {
+        const id = parseInt(String(args.ticketId), 10);
+        const comment = await this.storage.addComment(id, {
+          text: args.text,
+          author: args.author || "Agent"
+        });
+        return comment;
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  }
+};
+
+// src/upgrade.ts
+import crypto2 from "node:crypto";
+import fs5 from "node:fs";
+import path5 from "node:path";
+
+// src/server/daemon.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+import os from "node:os";
+import http from "node:http";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
+function getGlobalEsedreDir() {
+  return path4.join(os.homedir(), ".esedre");
+}
+function ensureGlobalEsedreStore() {
+  const globalDir = getGlobalEsedreDir();
+  const runDir = path4.join(globalDir, "run");
+  const logsDir = path4.join(globalDir, "logs");
+  try {
+    fs4.mkdirSync(runDir, { recursive: true });
+    fs4.mkdirSync(logsDir, { recursive: true });
+    try {
+      const runEntries = fs4.readdirSync(runDir);
+      for (const entry of runEntries) {
+        if (entry.startsWith(".probe-")) {
+          fs4.unlinkSync(path4.join(runDir, entry));
+        }
+      }
+    } catch {
+    }
+    const testProbe = path4.join(runDir, `.probe-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`);
+    try {
+      fs4.writeFileSync(testProbe, "ok", "utf-8");
+      return { ok: true, path: globalDir };
+    } finally {
+      if (fs4.existsSync(testProbe)) {
+        try {
+          fs4.unlinkSync(testProbe);
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    return { ok: false, path: globalDir, error: err.message };
+  }
+}
+function resolveStoreDir(workspaceRoot) {
+  const globalStore = ensureGlobalEsedreStore();
+  if (globalStore.ok) {
+    return globalStore.path;
+  }
+  if (workspaceRoot) {
+    const localStore = path4.join(workspaceRoot, ".esedre");
+    try {
+      fs4.mkdirSync(path4.join(localStore, "run"), { recursive: true });
+      fs4.mkdirSync(path4.join(localStore, "logs"), { recursive: true });
+      return localStore;
+    } catch {
+    }
+  }
+  return globalStore.path;
+}
+function getDaemonStateFile(port, workspaceRoot) {
+  const store = resolveStoreDir(workspaceRoot);
+  return path4.join(store, "run", `daemon-${port}.json`);
+}
+function getDaemonLogFile(port, workspaceRoot) {
+  const store = resolveStoreDir(workspaceRoot);
+  return path4.join(store, "logs", `daemon-${port}.log`);
+}
+function getDaemonState(port, workspaceRoot) {
+  const stateFile = getDaemonStateFile(port, workspaceRoot);
+  if (!fs4.existsSync(stateFile)) {
+    return null;
+  }
+  try {
+    const raw = fs4.readFileSync(stateFile, "utf-8").trim();
+    if (!raw) {
+      fs4.unlinkSync(stateFile);
+      return null;
+    }
+    const state = JSON.parse(raw);
+    if (!state || typeof state.pid !== "number" || typeof state.port !== "number") {
+      fs4.unlinkSync(stateFile);
+      return null;
+    }
+    return state;
+  } catch {
+    try {
+      fs4.unlinkSync(stateFile);
+    } catch {
+    }
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function pingDaemon(port, timeoutMs = 200) {
+  return new Promise((resolve) => {
+    const req = http.get(
+      `http://127.0.0.1:${port}/api/planning/projects`,
+      { timeout: timeoutMs },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            try {
+              const data = JSON.parse(body);
+              if (Array.isArray(data)) {
+                const projects = data.map((p) => p.code || p.name).filter(Boolean);
+                resolve({ responding: true, isEsedre: true, projects });
+                return;
+              }
+            } catch {
+            }
+            resolve({ responding: true, isEsedre: false });
+          } else {
+            resolve({ responding: true, isEsedre: false });
+          }
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ responding: false, isEsedre: false });
+    });
+    req.on("error", () => {
+      resolve({ responding: false, isEsedre: false });
+    });
+  });
+}
+async function startDaemon(options = {}) {
+  const port = options.port || 5674;
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const stateFile = getDaemonStateFile(port, workspaceRoot);
+  const logFile = getDaemonLogFile(port, workspaceRoot);
+  const existingState = getDaemonState(port, workspaceRoot);
+  if (existingState) {
+    if (isProcessAlive(existingState.pid)) {
+      const ping = await pingDaemon(port, 400);
+      if (ping.responding && ping.isEsedre) {
+        if (!options.quiet) {
+          console.log(`\x1B[36m\u26A1 Esedre daemon already running on http://localhost:${port} (PID ${existingState.pid})\x1B[0m`);
+        }
+        return existingState;
+      }
+    }
+    try {
+      fs4.unlinkSync(stateFile);
+    } catch {
+    }
+  }
+  const portPing = await pingDaemon(port, 200);
+  if (portPing.responding && portPing.isEsedre) {
+    if (!options.quiet) {
+      console.log(`\x1B[36m\u26A1 Esedre server already active on http://localhost:${port}\x1B[0m`);
+    }
+    return {
+      pid: process.pid,
+      port,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "0.1.0",
+      workspaceRoot,
+      logFile
+    };
+  }
+  resolveStoreDir(workspaceRoot);
+  fs4.mkdirSync(path4.dirname(logFile), { recursive: true });
+  fs4.mkdirSync(path4.dirname(stateFile), { recursive: true });
+  const logFd = fs4.openSync(logFile, "a");
+  const isEsedreArgv1 = process.argv[1] && /esedre/i.test(path4.basename(process.argv[1]));
+  const cliCandidates = [
+    isEsedreArgv1 ? process.argv[1] : void 0,
+    path4.resolve(workspaceRoot, "dist", "esedre.mjs"),
+    path4.resolve(workspaceRoot, "../esedre/dist", "esedre.mjs"),
+    path4.resolve(__dirname, "esedre.mjs"),
+    path4.resolve(__dirname, "..", "dist", "esedre.mjs"),
+    path4.resolve(__dirname, "..", "..", "dist", "esedre.mjs"),
+    path4.resolve(__dirname, "..", "..", "bin", "esedre.js"),
+    path4.resolve(__dirname, "..", "..", "bin", "esedre.ts"),
+    path4.resolve(__dirname, "..", "esedre.mjs"),
+    path4.resolve(__dirname, "../../../esedre/dist", "esedre.mjs")
+  ].filter(Boolean);
+  const cliPath = cliCandidates.find((c) => fs4.existsSync(c) && (c.endsWith(".mjs") || c.endsWith(".js") || c.endsWith(".ts"))) || cliCandidates[0];
+  if (!fs4.existsSync(cliPath)) {
+    throw new Error(`Could not locate Esedre executable. Searched candidates: ${cliCandidates.join(", ")}`);
+  }
+  const child = spawn(process.execPath, [cliPath, "serve", "--port", String(port)], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: workspaceRoot,
+    env: { ...process.env },
+    windowsHide: true
+  });
+  child.unref();
+  const pid = child.pid;
+  if (!pid) {
+    throw new Error("Failed to spawn Esedre daemon background process.");
+  }
+  const startTime = Date.now();
+  let ready = false;
+  while (Date.now() - startTime < 3500) {
+    await new Promise((r) => setTimeout(r, 100));
+    const ping = await pingDaemon(port, 150);
+    if (ping.responding && ping.isEsedre) {
+      ready = true;
+      break;
+    }
+  }
+  if (!ready) {
+    try {
+      if (process.platform === "win32") {
+        spawn("taskkill", ["/pid", String(pid), "/f", "/t"], { shell: false });
+      } else {
+        process.kill(pid, "SIGTERM");
+      }
+    } catch {
+    }
+    throw new Error(`Esedre daemon failed to start on port ${port} within timeout. Check logs at: ${logFile}`);
+  }
+  const state = {
+    pid,
+    port,
+    uiPort: port + 1,
+    apiPort: port + 2,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "0.1.0",
+    workspaceRoot,
+    logFile
+  };
+  const tmpState = `${stateFile}.tmp.${Date.now()}`;
+  fs4.writeFileSync(tmpState, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  try {
+    fs4.renameSync(tmpState, stateFile);
+  } catch {
+    fs4.writeFileSync(stateFile, JSON.stringify(state, null, 2) + "\n", "utf-8");
+    try {
+      fs4.unlinkSync(tmpState);
+    } catch {
+    }
+  }
+  if (!options.quiet) {
+    console.log(`\x1B[32m\u2714 Started Esedre background daemon on http://localhost:${port} (PID ${pid})\x1B[0m`);
+    console.log(`  \u2022 Web UI:   http://localhost:${port}`);
+    console.log(`  \u2022 Logs:     ${logFile}`);
+  }
+  return state;
+}
+async function stopDaemon(options = {}) {
+  const port = options.port || 5674;
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const stateFile = getDaemonStateFile(port, workspaceRoot);
+  const state = getDaemonState(port, workspaceRoot);
+  let pid = state?.pid;
+  if (!pid) {
+    const ping = await pingDaemon(port, 200);
+    if (!ping.responding) {
+      if (!options.quiet) {
+        console.log(`\x1B[33m\u25CB Esedre daemon is not running on port ${port}.\x1B[0m`);
+      }
+      return false;
+    }
+  }
+  if (pid && isProcessAlive(pid)) {
+    try {
+      if (process.platform === "win32") {
+        spawnSync("taskkill", ["/pid", String(pid), "/f", "/t"], { shell: false, stdio: "ignore" });
+      } else {
+        process.kill(pid, "SIGTERM");
+      }
+    } catch (err) {
+      console.warn(`Warning terminating PID ${pid}: ${err.message}`);
+    }
+    const stopStart = Date.now();
+    while (isProcessAlive(pid) && Date.now() - stopStart < 2e3) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  try {
+    if (fs4.existsSync(stateFile)) {
+      fs4.unlinkSync(stateFile);
+    }
+  } catch {
+  }
+  if (!options.quiet) {
+    console.log(`\x1B[32m\u2714 Stopped Esedre daemon on port ${port}${pid ? ` (PID ${pid})` : ""}\x1B[0m`);
+  }
+  return true;
+}
+async function getDaemonStatus(options = {}) {
+  const port = options.port || 5674;
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const state = getDaemonState(port, workspaceRoot);
+  const stateFile = getDaemonStateFile(port, workspaceRoot);
+  const logFile = getDaemonLogFile(port, workspaceRoot);
+  const ping = await pingDaemon(port, 300);
+  if (state && isProcessAlive(state.pid) && ping.responding && ping.isEsedre) {
+    const startedMs = Date.parse(state.startedAt) || Date.now();
+    const uptimeSeconds = Math.max(0, Math.floor((Date.now() - startedMs) / 1e3));
+    return {
+      running: true,
+      pid: state.pid,
+      port: state.port,
+      uptimeSeconds,
+      startedAt: state.startedAt,
+      workspaceRoot: state.workspaceRoot,
+      projects: ping.projects,
+      logFile: state.logFile || logFile
+    };
+  }
+  if (state && !isProcessAlive(state.pid)) {
+    try {
+      fs4.unlinkSync(stateFile);
+    } catch {
+    }
+  }
+  return {
+    running: ping.responding && ping.isEsedre,
+    port,
+    projects: ping.projects,
+    logFile
+  };
+}
+function printDaemonLogs(options = {}) {
+  const port = options.port || 5674;
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const logFile = getDaemonLogFile(port, workspaceRoot);
+  if (!fs4.existsSync(logFile)) {
+    console.log(`\x1B[33mNo logs found at: ${logFile}\x1B[0m`);
+    return;
+  }
+  const content = fs4.readFileSync(logFile, "utf-8");
+  const count = options.lines || 40;
+  const allLines = content.split(/\r?\n/);
+  const tail = allLines.slice(-count).join("\n");
+  console.log(`\x1B[36m--- Esedre Daemon Logs (${logFile}) ---\x1B[0m
+`);
+  console.log(tail);
+}
+
+// src/upgrade.ts
+var CURRENT_ESEDRE_VERSION = "0.1.3";
+function computeNormalizedHash(content) {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  return crypto2.createHash("sha1").update(normalized, "utf-8").digest("hex");
+}
+function classifyContent(currentContent, latestTemplate, historicHashes) {
+  if (!currentContent || currentContent.trim().length === 0) {
+    return "MISSING";
+  }
+  const currentHash = computeNormalizedHash(currentContent);
+  const latestHash = computeNormalizedHash(latestTemplate);
+  if (currentHash === latestHash) {
+    return "LATEST";
+  }
+  if (historicHashes.includes(currentHash)) {
+    return "HISTORIC_DEFAULT";
+  }
+  return "CUSTOMIZED";
+}
+var WRAPPER_CMD = `@echo off
+REM Esedre Autonomous Ticketing & Project Planning Engine Wrapper (Windows CMD)
+setlocal
+where ese >nul 2>nul
+if %ERRORLEVEL% equ 0 (
+  ese %*
+  goto :done
+)
+where esedre >nul 2>nul
+if %ERRORLEVEL% equ 0 (
+  esedre %*
+  goto :done
+)
+if exist "%~dp0..\\..\\esedre\\dist\\esedre.mjs" (
+  node "%~dp0..\\..\\esedre\\dist\\esedre.mjs" %*
+  goto :done
+)
+if exist "%~dp0..\\esedre\\dist\\esedre.mjs" (
+  node "%~dp0..\\esedre\\dist\\esedre.mjs" %*
+  goto :done
+)
+if exist "%~dp0..\\node_modules\\.bin\\ese.cmd" (
+  call "%~dp0..\\node_modules\\.bin\\ese.cmd" %*
+  goto :done
+)
+if exist "%~dp0..\\node_modules\\.bin\\esedre.cmd" (
+  call "%~dp0..\\node_modules\\.bin\\esedre.cmd" %*
+  goto :done
+)
+npx --yes esedre %*
+
+:done
+endlocal
+exit /b %ERRORLEVEL%
+`;
+var WRAPPER_PS1 = `# Esedre Autonomous Ticketing & Project Planning Engine Wrapper (PowerShell)
+$ErrorActionPreference = "Stop"
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+
+if (Get-Command "ese" -ErrorAction SilentlyContinue) {
+    & ese @args
+    exit $LASTEXITCODE
+}
+if (Get-Command "esedre" -ErrorAction SilentlyContinue) {
+    & esedre @args
+    exit $LASTEXITCODE
+}
+$siblingEsedre = Join-Path $scriptDir "..\\..\\esedre\\dist\\esedre.mjs"
+if (Test-Path $siblingEsedre) {
+    & node $siblingEsedre @args
+    exit $LASTEXITCODE
+}
+$distEsedre = Join-Path $scriptDir "..\\esedre\\dist\\esedre.mjs"
+if (Test-Path $distEsedre) {
+    & node $distEsedre @args
+    exit $LASTEXITCODE
+}
+$localBin = Join-Path $scriptDir "..\\node_modules\\.bin\\ese.cmd"
+if (Test-Path $localBin) {
+    & $localBin @args
+    exit $LASTEXITCODE
+}
+$localEsedreBin = Join-Path $scriptDir "..\\node_modules\\.bin\\esedre.cmd"
+if (Test-Path $localEsedreBin) {
+    & $localEsedreBin @args
+    exit $LASTEXITCODE
+}
+& npx --yes esedre @args
+exit $LASTEXITCODE
+`;
+var WRAPPER_BASH = `#!/usr/bin/env bash
+# Esedre Autonomous Ticketing & Project Planning Engine Wrapper (POSIX)
+set -e
+DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
+
+if command -v ese >/dev/null 2>&1; then
+  exec ese "$@"
+fi
+if command -v esedre >/dev/null 2>&1; then
+  exec esedre "$@"
+fi
+if [ -f "$DIR/../../esedre/dist/esedre.mjs" ]; then
+  exec node "$DIR/../../esedre/dist/esedre.mjs" "$@"
+fi
+if [ -f "$DIR/../esedre/dist/esedre.mjs" ]; then
+  exec node "$DIR/../esedre/dist/esedre.mjs" "$@"
+fi
+if [ -f "$DIR/../node_modules/.bin/ese" ]; then
+  exec "$DIR/../node_modules/.bin/ese" "$@"
+fi
+if [ -f "$DIR/../node_modules/.bin/esedre" ]; then
+  exec "$DIR/../node_modules/.bin/esedre" "$@"
+fi
+exec npx --yes esedre "$@"
+`;
+var ESE_WRAPPER_CMD = `@echo off
+REM Ese CLI short alias wrapper for Esedre (Windows CMD)
+call "%~dp0esedre.cmd" %*
+`;
+var ESE_WRAPPER_PS1 = `# Ese CLI short alias wrapper for Esedre (PowerShell)
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+& (Join-Path $scriptDir "esedre.ps1") @args
+exit $LASTEXITCODE
+`;
+var ESE_WRAPPER_BASH = `#!/usr/bin/env bash
+# Ese CLI short alias wrapper for Esedre (POSIX)
+DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
+exec "$DIR/esedre" "$@"
+`;
+var ESEDRE_SKILL_TEMPLATE = '---\nname: esedre\ndescription: Tooling and workflow reference for interacting with the Esedre developer ticketing and roadmap system. Use this skill whenever inspecting planned work, viewing ticket specs, updating implementation plans, or posting developer notes.\n---\n\n# Esedre Planning & Roadmap Workflow\n\nEsedre is the developer ticketing and companion LLM coding agent coordination platform. The engine codebase resides in the standalone repository `aellinsar/esedre` (`../esedre`), and operates on decoupled ticket repositories (such as `aellinsar/esedre-data` configured in `.esedre/esedre.json`). In `ProfessorArwamSleepCenter`, interact with tickets via the compiled bridge artifact `tools/esedre.mjs` (`node tools/esedre.mjs <command>`), in-repo shell wrappers in `.esedre/` (`.esedre/ese`), or the global `ese` CLI.\n\n## 0. Instant Zero-Latency Context (`.esedre/snapshot.json`)\n\nBefore querying tickets over the network or CLI, check `.esedre/snapshot.json` in the workspace root. It provides a local read-only projection containing all active and completed tickets, summaries, implementation plans, revision numbers, completion dates (`completedAt`), and staleness metrics (`daysSinceUpdate`).\n\n## 1. Model Context Protocol (MCP) Tools\n\nWhen Esedre MCP is active in your agent session (`.agents/mcp_config.json`), use these tools directly:\n\n| Tool | Purpose | Key Arguments |\n|---|---|---|\n| `esedre_list_tickets` | List roadmap tickets with filters | `project` (e.g. `Profe`, `Esedre`, `Alce`), `status`, `type`, `search` |\n| `esedre_get_ticket` | Full specification, summary, comments, revision & sha1 | `ticketId` (numeric or compound e.g. `Profe-35`) |\n| `esedre_get_plan` | Active implementation plan markdown | `ticketId` (numeric or compound) |\n| `esedre_save_plan` | Save implementation plan markdown with OCC | `ticketId`, `planMarkdown`, `lastHash` |\n| `esedre_create_ticket` | Mint a new ticket with auto sequential ID | `title` (max 48 chars), `type`, `project`, `effort`, `summary` |\n| `esedre_update_ticket` | Update ticket attributes with OCC | `ticketId`, `status`, `title`, `inDevelopment`, `featureFlag`, `lastHash` |\n\n## 2. Core CLI Commands (Fallback via `run_command`)\n\nBoth `esedre` and `ese` work interchangeably:\n\n### List Tickets\n```bash\n.esedre/ese list [-p|--project <code|all>] [-s|--status <status>] [-t|--type <type>] [-q|--search <q>] [--json]\n```\n\n### Read Ticket Details\n```bash\n.esedre/ese get <ticketId> [--json]\n```\n\n### Read or Update Implementation Plans\n```bash\n.esedre/ese plan <ticketId>\n.esedre/ese plan <ticketId> --file <planFilePath>\n.esedre/ese plan <ticketId> --set "<markdownContent>" [--last-hash <hash>]\n```\n\n### Create a Ticket\n```bash\n.esedre/ese create --title "..." [-p|--project Profe] [-t|--type Feature] [--complexity Medium] [--effort "2.0 - 4.0 hours"] [--json]\n```\n\n### Update Ticket Status\n```bash\n.esedre/ese update <ticketId> --status "In Development"\n.esedre/ese update <ticketId> --status "Completed"\n```\n\n### Append Comments or Notes\n```bash\n.esedre/ese comment <ticketId> --text "Verified implementation." --author "Antigravity"\n```\n\n### Regenerate Snapshot\n```bash\n.esedre/ese snapshot\n```\n\n### Background Daemon Management\n```bash\n# Start background daemon on port 5674 (idempotent)\n.esedre/ese daemon start [--port 5674] [--quiet] [--json]\n\n# Check daemon health and diagnostics\n.esedre/ese daemon status [--port 5674] [--json]\n\n# View recent daemon activity logs\n.esedre/ese daemon logs\n\n# Stop background daemon\n.esedre/ese daemon stop [--port 5674] [--quiet] [--json]\n```\n\n### Foreground Gateway Server\n```bash\n.esedre/ese serve [--port 5674]\n```\n- Starts the unified gateway on port 5674, routing `/app` to Esedre UI (port 5675) and `/api` to Esedre REST API (port 5676).\n- Transparently rewrites `/` to `/app/`.\n\n### Workspace Configuration & Vite Proxy Setup\n```bash\n.esedre/ese configure [--project <code>] [--name <name>] [--port <n>] [--proxy] [--no-proxy] [-y]\n```\n- Automatically detects `vite.config.ts`/`vite.config.js`. In interactive mode or with `--proxy`, configures a reverse proxy for `/esedre` targeting port 5674 (`http://127.0.0.1:5674`).\n- If Vite is absent or declined, displays the recommended reverse proxy block for embedding the planner UI in the host app.\n\n## 3. Embedded View & Theme Token Contract\n\nWhen embedding `<PlannedWorkView />` inside a host app (e.g. `PlannedWorkModal.tsx`):\n\n### Zero-Effort Drop-in (Default Fallback)\n`PlannedWorkView` incorporates an internal CSS fallback bridge (`.esedre-host-bridge` / `.esedre-theme-root` with `ESEDRE_THEME_FALLBACK_CSS`).\nIf an embedding application supplies **zero CSS variables**, the component automatically falls back to clean, high-contrast light or dark themes matching the user\'s OS preference (`prefers-color-scheme: dark`) or host `.dark` / `[data-theme="night"]` classes.\n\n### Theme Token Customization\nIf the host application declares any or all of the 12 core design tokens on `:root` or an ancestor container, `PlannedWorkView` automatically adopts them:\n- **Surface**: `--bg-surface`, `--bg-surface-elevated`, `--bg-input`\n- **Borders**: `--border-subtle`, `--border-strong`, `--border-accent`\n- **Text**: `--text-primary`, `--text-secondary`, `--text-muted`\n- **Accent**: `--accent-primary`, `--accent-bg-subtle`, `--accent-border-subtle`\n\n## 4. Safety & Invariants\n- **Always use `--json`** for CLI programmatic inspection.\n- **Optimistic Concurrency**: Writes support `--last-hash <hash>` to prevent overwriting concurrent updates.\n- **Universal Type Naming**: Always use `type` (`Feature`, `Platform`, `Tools`, `Idea`, `Bug`). The legacy name `category` is deprecated.\n- **Compound IDs for Multi-Project Portfolios**: In `project=all`, ticket IDs are `${projectCode}-${id}` (e.g. `Profe-1`, `Esedre-1`). DOM anchors strictly use `feature-card-${projectCode}-${id}`.\n- **Never delete tickets** directly via filesystem.\n- **Agent Project Allow-List**: Providing isolation of projects planning that you don\'t want an agent to access. A repository only accesses projects declared in its `.esedre/esedre.json` (`allowedProjects`). Unauthorized cross-project access is strictly blocked.\n- **Secret Developer Hash Route (`#/planner`, `#/plan`, `#planner`, `#plan`)**:\n  - In web applications embedding Esedre (such as Professor Arwam), `#/planner` and `#/plan` serve as direct secret developer entry routes.\n  - **SEO Invariant**: These developer routes are private and MUST NEVER be exposed in `sitemap.xml`, `robots.txt`, `llms.txt`, or public navigation links.\n  - The URL hash is preserved across hard page refreshes (F5) without falling back to `#/chat` or other views.\n';
+function plantWrappers(targetDir) {
+  const esedreDir = path5.join(targetDir, ".esedre");
+  fs5.mkdirSync(esedreDir, { recursive: true });
+  const wrappers = [
+    { name: "esedre.cmd", content: WRAPPER_CMD, exec: false },
+    { name: "esedre.ps1", content: WRAPPER_PS1, exec: false },
+    { name: "esedre", content: WRAPPER_BASH, exec: true },
+    { name: "ese.cmd", content: ESE_WRAPPER_CMD, exec: false },
+    { name: "ese.ps1", content: ESE_WRAPPER_PS1, exec: false },
+    { name: "ese", content: ESE_WRAPPER_BASH, exec: true }
+  ];
+  for (const w of wrappers) {
+    const fullPath = path5.join(esedreDir, w.name);
+    fs5.writeFileSync(fullPath, w.content, "utf-8");
+    if (w.exec) {
+      try {
+        fs5.chmodSync(fullPath, 493);
+      } catch {
+      }
+    }
+  }
+}
+function setupMcpConfig(targetDir) {
+  const agentsDir = path5.join(targetDir, ".agents");
+  fs5.mkdirSync(agentsDir, { recursive: true });
+  const mcpConfigPath = path5.join(agentsDir, "mcp_config.json");
+  let configObj = { mcpServers: {} };
+  if (fs5.existsSync(mcpConfigPath)) {
+    try {
+      configObj = JSON.parse(fs5.readFileSync(mcpConfigPath, "utf-8"));
+      if (!configObj.mcpServers) configObj.mcpServers = {};
+    } catch {
+    }
+  }
+  if (process.platform === "win32") {
+    configObj.mcpServers.esedre = {
+      command: "cmd.exe",
+      args: ["/c", ".esedre\\esedre.cmd", "mcp"]
+    };
+  } else {
+    configObj.mcpServers.esedre = {
+      command: ".esedre/esedre",
+      args: ["mcp"]
+    };
+  }
+  try {
+    fs5.writeFileSync(mcpConfigPath, JSON.stringify(configObj, null, 2) + "\n", "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setupSkill(targetDir) {
+  const skillDir = path5.join(targetDir, ".agents", "skills", "esedre");
+  fs5.mkdirSync(skillDir, { recursive: true });
+  const skillFile = path5.join(skillDir, "SKILL.md");
+  if (!fs5.existsSync(skillFile)) {
+    fs5.writeFileSync(skillFile, ESEDRE_SKILL_TEMPLATE, "utf-8");
+    return { status: "MISSING", updated: true };
+  }
+  const currentContent = fs5.readFileSync(skillFile, "utf-8");
+  const status = classifyContent(currentContent, ESEDRE_SKILL_TEMPLATE, []);
+  if (status === "LATEST") {
+    return { status, updated: false };
+  }
+  if (status === "HISTORIC_DEFAULT" || status === "MISSING") {
+    fs5.writeFileSync(skillFile, ESEDRE_SKILL_TEMPLATE, "utf-8");
+    return { status, updated: true };
+  }
+  return { status, updated: false };
+}
+var VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.mts",
+  "vite.config.cjs"
+];
+function findViteConfig(targetDir) {
+  for (const name of VITE_CONFIG_FILES) {
+    const fullPath = path5.join(targetDir, name);
+    if (fs5.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function getRecommendedViteProxySnippet(port = DEFAULT_ESEDRE_PORT) {
+  return `proxy: {
+  '/esedre': {
+    target: 'http://127.0.0.1:${port}',
+    changeOrigin: true,
+    rewrite: (path) => path.replace(/^\\/esedre/, ''),
+  },
+}`;
+}
+function detectLineEnding(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function injectViteProxy(content, port = DEFAULT_ESEDRE_PORT) {
+  if (content.includes("'/esedre'") || content.includes('"/esedre"')) {
+    return content;
+  }
+  const eol = detectLineEnding(content);
+  const proxyMatch = content.match(/(proxy\s*:\s*\{)/);
+  if (proxyMatch && proxyMatch.index !== void 0) {
+    const insertIdx = proxyMatch.index + proxyMatch[0].length;
+    const snippet = `${eol}      '/esedre': {${eol}        target: 'http://127.0.0.1:${port}',${eol}        changeOrigin: true,${eol}        rewrite: (path) => path.replace(/^\\/esedre/, ''),${eol}      },`;
+    return content.slice(0, insertIdx) + snippet + content.slice(insertIdx);
+  }
+  const serverMatch = content.match(/(server\s*:\s*\{)/);
+  if (serverMatch && serverMatch.index !== void 0) {
+    const insertIdx = serverMatch.index + serverMatch[0].length;
+    const snippet = `${eol}    proxy: {${eol}      '/esedre': {${eol}        target: 'http://127.0.0.1:${port}',${eol}        changeOrigin: true,${eol}        rewrite: (path) => path.replace(/^\\/esedre/, ''),${eol}      },${eol}    },`;
+    return content.slice(0, insertIdx) + snippet + content.slice(insertIdx);
+  }
+  const returnMatch = content.match(/(return\s*\{)/);
+  if (returnMatch && returnMatch.index !== void 0) {
+    const insertIdx = returnMatch.index + returnMatch[0].length;
+    const snippet = `${eol}    server: {${eol}      proxy: {${eol}        '/esedre': {${eol}          target: 'http://127.0.0.1:${port}',${eol}          changeOrigin: true,${eol}          rewrite: (path) => path.replace(/^\\/esedre/, ''),${eol}        },${eol}      },${eol}    },`;
+    return content.slice(0, insertIdx) + snippet + content.slice(insertIdx);
+  }
+  const defineMatch = content.match(/(defineConfig\s*\(\s*\{)/);
+  if (defineMatch && defineMatch.index !== void 0) {
+    const insertIdx = defineMatch.index + defineMatch[0].length;
+    const snippet = `${eol}  server: {${eol}    proxy: {${eol}      '/esedre': {${eol}        target: 'http://127.0.0.1:${port}',${eol}        changeOrigin: true,${eol}        rewrite: (path) => path.replace(/^\\/esedre/, ''),${eol}      },${eol}    },${eol}  },`;
+    return content.slice(0, insertIdx) + snippet + content.slice(insertIdx);
+  }
+  const exportMatch = content.match(/(export\s+default\s*\{)/);
+  if (exportMatch && exportMatch.index !== void 0) {
+    const insertIdx = exportMatch.index + exportMatch[0].length;
+    const snippet = `${eol}  server: {${eol}    proxy: {${eol}      '/esedre': {${eol}        target: 'http://127.0.0.1:${port}',${eol}        changeOrigin: true,${eol}        rewrite: (path) => path.replace(/^\\/esedre/, ''),${eol}      },${eol}    },${eol}  },`;
+    return content.slice(0, insertIdx) + snippet + content.slice(insertIdx);
+  }
+  return null;
+}
+function configureViteProxy(targetDir, port = DEFAULT_ESEDRE_PORT, setupProxy) {
+  const configPath = findViteConfig(targetDir);
+  const snippet = getRecommendedViteProxySnippet(port);
+  if (!configPath) {
+    return {
+      status: "NOT_APPLICABLE",
+      recommendedProxySnippet: snippet
+    };
+  }
+  const relativeName = path5.basename(configPath);
+  let content = "";
+  try {
+    content = fs5.readFileSync(configPath, "utf-8");
+  } catch {
+    return {
+      status: "MANUAL_REQUIRED",
+      configFile: relativeName,
+      recommendedProxySnippet: snippet
+    };
+  }
+  if (content.includes("'/esedre'") || content.includes('"/esedre"')) {
+    return {
+      status: "ALREADY_CONFIGURED",
+      configFile: relativeName,
+      recommendedProxySnippet: snippet
+    };
+  }
+  if (setupProxy !== true) {
+    return {
+      status: "SKIPPED",
+      configFile: relativeName,
+      recommendedProxySnippet: snippet
+    };
+  }
+  const injected = injectViteProxy(content, port);
+  if (!injected) {
+    return {
+      status: "MANUAL_REQUIRED",
+      configFile: relativeName,
+      recommendedProxySnippet: snippet
+    };
+  }
+  try {
+    fs5.writeFileSync(configPath, injected, "utf-8");
+    return {
+      status: "CONFIGURED",
+      configFile: relativeName,
+      recommendedProxySnippet: snippet
+    };
+  } catch {
+    return {
+      status: "MANUAL_REQUIRED",
+      configFile: relativeName,
+      recommendedProxySnippet: snippet
+    };
+  }
+}
+function configureWorkspace(targetDir, options = {}) {
+  const esedreDir = path5.join(targetDir, ".esedre");
+  if (!fs5.existsSync(esedreDir)) {
+    fs5.mkdirSync(esedreDir, { recursive: true });
+  }
+  const esedreJsonPath = path5.join(esedreDir, "esedre.json");
+  let existingRaw = null;
+  if (fs5.existsSync(esedreJsonPath)) {
+    try {
+      existingRaw = JSON.parse(fs5.readFileSync(esedreJsonPath, "utf-8"));
+    } catch {
+    }
+  }
+  let config;
+  const projectCode = options.projectCode || existingRaw?.projectCode;
+  const projectName = options.projectName || existingRaw?.projectName || (projectCode ? projectCode : void 0);
+  if (existingRaw) {
+    config = migrateEsedreConfig(existingRaw, CURRENT_ESEDRE_VERSION);
+    if (projectCode) config.projectCode = projectCode;
+    if (projectName) config.projectName = projectName;
+    if (options.allowedProjects) {
+      config.allowedProjects = options.allowedProjects;
+    } else if (projectCode) {
+      if (!config.allowedProjects) {
+        config.allowedProjects = [projectCode];
+      } else if (!config.allowedProjects.some((p) => p.toUpperCase() === projectCode.toUpperCase())) {
+        config.allowedProjects.push(projectCode);
+      }
+    }
+    if (options.port) config.port = options.port;
+  } else {
+    config = {
+      version: CURRENT_ESEDRE_VERSION,
+      projectCode: projectCode || void 0,
+      projectName: projectName || void 0,
+      allowedProjects: options.allowedProjects || (projectCode ? [projectCode] : void 0),
+      port: options.port || DEFAULT_ESEDRE_PORT
+    };
+  }
+  fs5.writeFileSync(esedreJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  let projectRegistered = false;
+  if (projectCode) {
+    const ticketsDir = path5.join(esedreDir, "tickets");
+    if (!fs5.existsSync(ticketsDir)) {
+      fs5.mkdirSync(ticketsDir, { recursive: true });
+    }
+    const inRepoPJson = path5.join(esedreDir, "project.json");
+    if (!fs5.existsSync(inRepoPJson)) {
+      const projDesc = {
+        id: 1,
+        code: projectCode.toUpperCase(),
+        slug: projectCode.toLowerCase(),
+        name: projectName || projectCode.toUpperCase(),
+        description: `${projectName || projectCode.toUpperCase()} project`,
+        colors: {
+          badge: "border-cyan-500/30 bg-cyan-500/10 text-cyan-300",
+          dot: "bg-cyan-400",
+          border: "border-cyan-500/40"
+        }
+      };
+      fs5.writeFileSync(inRepoPJson, JSON.stringify(projDesc, null, 2) + "\n", "utf-8");
+      projectRegistered = true;
+    } else if (projectName) {
+      try {
+        const existing = JSON.parse(fs5.readFileSync(inRepoPJson, "utf-8"));
+        if (existing.name !== projectName) {
+          existing.name = projectName;
+          fs5.writeFileSync(inRepoPJson, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+        }
+      } catch {
+      }
+    }
+  }
+  plantWrappers(targetDir);
+  const gitignoreUpdated = appendSnapshotToGitIgnore(targetDir);
+  let mcpConfigured = false;
+  if (options.setupMcp !== false) {
+    mcpConfigured = setupMcpConfig(targetDir);
+  }
+  const skillRes = setupSkill(targetDir);
+  const proxyRes = configureViteProxy(targetDir, config.port || DEFAULT_ESEDRE_PORT, options.setupProxy);
+  const globalStoreRes = ensureGlobalEsedreStore();
+  if (!globalStoreRes.ok) {
+    console.warn(`\x1B[33m\u26A0\uFE0F Warning: Could not initialize global store at ${globalStoreRes.path}: ${globalStoreRes.error}\x1B[0m`);
+  }
+  return {
+    esedreJsonCreatedOrUpdated: true,
+    projectRegistered,
+    projectName: config.projectName || config.projectCode,
+    wrappersPlanted: true,
+    gitignoreUpdated,
+    mcpConfigured,
+    skillConfigured: skillRes.updated,
+    skillStatus: skillRes.status,
+    viteProxyStatus: proxyRes.status,
+    viteConfigFile: proxyRes.configFile,
+    recommendedProxySnippet: proxyRes.recommendedProxySnippet,
+    globalStoreStatus: globalStoreRes.ok ? "ready" : "warning",
+    globalStorePath: globalStoreRes.path,
+    globalStoreError: globalStoreRes.error
+  };
+}
+
+// src/server/gateway.ts
+import fs7 from "node:fs";
+import http4 from "node:http";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/server/uiServer.ts
+import http2 from "node:http";
+import fs6 from "node:fs";
+import path6 from "node:path";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon"
+};
+function startUiServer(port, webDir) {
+  const server = http2.createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    let reqPath = (req.url || "/").split("?")[0];
+    if (reqPath === "/app" || reqPath === "/app/") {
+      reqPath = "/";
+    } else if (reqPath.startsWith("/app/")) {
+      reqPath = reqPath.slice("/app".length);
+    }
+    if (!reqPath || reqPath === "/") {
+      reqPath = "/index.html";
+    }
+    const safePath = path6.normalize(reqPath).replace(/^(\.\.[/\\])+/, "");
+    let filePath = path6.join(webDir, safePath);
+    if (!fs6.existsSync(filePath) || fs6.statSync(filePath).isDirectory()) {
+      filePath = path6.join(webDir, "index.html");
+    }
+    if (!fs6.existsSync(filePath)) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Esedre UI: index.html not found. Run npm run build first.");
+      return;
+    }
+    const ext = path6.extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    try {
+      const content = fs6.readFileSync(filePath);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content);
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end(`Internal Server Error: ${err.message}`);
+    }
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`\x1B[31mError: Internal UI port ${port} is already in use.\x1B[0m`);
+    } else {
+      console.error(`\x1B[31mUI Server Error: ${err.message}\x1B[0m`);
+    }
+  });
+  server.listen(port, "127.0.0.1", () => {
+  });
+  return server;
+}
+
+// src/server/apiServer.ts
+import http3 from "node:http";
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      if (!body) return resolve({});
+      try {
+        resolve(JSON.parse(body));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, data) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization"
+  });
+  res.end(JSON.stringify(data));
+}
+var cachedAllData = null;
+var cachedAllTimestamp = 0;
+var CACHE_TTL_MS = 5e3;
+function invalidateApiCache() {
+  cachedAllData = null;
+  cachedAllTimestamp = 0;
+}
+function createApiHandler(storage, workspaceRoot) {
+  return async (req, res) => {
+    const rawUrl = req.url || "/";
+    const parsedPath = rawUrl.split("?")[0];
+    if (req.method === "OPTIONS") {
+      if (parsedPath.startsWith("/api") || parsedPath.startsWith("/esedre/api")) {
+        res.writeHead(204, {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+        });
+        res.end();
+        return true;
+      }
+      return false;
+    }
+    if (!parsedPath.startsWith("/api") && !parsedPath.startsWith("/esedre/api")) {
+      return false;
+    }
+    const url = new URL(rawUrl, "http://127.0.0.1");
+    let pathname = url.pathname;
+    if (pathname.startsWith("/esedre/api")) {
+      pathname = pathname.slice("/esedre".length);
+    }
+    try {
+      if (req.method === "GET") {
+        if (pathname === "/api/planning/projects") {
+          const projects = await storage.getProjects();
+          sendJson(res, 200, projects);
+          return true;
+        }
+        if (pathname === "/api/planning/tickets") {
+          const project = url.searchParams.get("project") || void 0;
+          const status = url.searchParams.get("status") || void 0;
+          const type = url.searchParams.get("type") || url.searchParams.get("category") || void 0;
+          const category = type;
+          const search = url.searchParams.get("search") || void 0;
+          const tickets = await storage.listTickets({
+            project: project === "all" ? void 0 : project,
+            status,
+            type,
+            category,
+            search
+          });
+          sendJson(res, 200, tickets);
+          return true;
+        }
+        if (pathname.startsWith("/api/planning/ticket/")) {
+          const idStr = pathname.slice("/api/planning/ticket/".length);
+          if (!idStr || !/^([a-zA-Z0-9]{1,6}-)?\d+$/.test(idStr)) {
+            sendJson(res, 400, { error: "Invalid ticket ID" });
+            return true;
+          }
+          const ticket = await storage.getTicket(idStr);
+          if (!ticket) {
+            sendJson(res, 400, { error: "Ticket not found" });
+            return true;
+          }
+          sendJson(res, 200, ticket);
+          return true;
+        }
+        if (pathname === "/api/planning/all") {
+          const now = Date.now();
+          if (cachedAllData && now - cachedAllTimestamp < CACHE_TTL_MS) {
+            sendJson(res, 200, cachedAllData);
+            return true;
+          }
+          const tickets = await storage.listTickets({});
+          const metasMap = {};
+          const detailsMap = {};
+          const plansMap = {};
+          const commentsMap = {};
+          for (const t of tickets) {
+            const numKey = String(t.meta.id);
+            const code = t.projectDescriptor?.code || t.meta.project || "Profe";
+            const prefixedKey = `${code}-${t.meta.id}`;
+            metasMap[prefixedKey] = t.meta;
+            if (!metasMap[numKey] || code.toUpperCase() === "PROF") {
+              metasMap[numKey] = t.meta;
+            }
+            commentsMap[prefixedKey] = t.comments || [];
+            if (!commentsMap[numKey] || code.toUpperCase() === "PROF") {
+              commentsMap[numKey] = t.comments || [];
+            }
+            if (t.detail?.raw) {
+              detailsMap[prefixedKey] = t.detail.raw;
+              if (!detailsMap[numKey] || code.toUpperCase() === "PROF") {
+                detailsMap[numKey] = t.detail.raw;
+              }
+            }
+            if (t.planMarkdown) {
+              plansMap[prefixedKey] = t.planMarkdown;
+              if (!plansMap[numKey] || code.toUpperCase() === "PROF") {
+                plansMap[numKey] = t.planMarkdown;
+              }
+            }
+          }
+          const projects = await storage.getProjects();
+          const responsePayload = {
+            success: true,
+            projects,
+            metas: metasMap,
+            details: detailsMap,
+            plans: plansMap,
+            comments: commentsMap,
+            answers: {},
+            inlineComments: {},
+            planHistory: {},
+            ticketHistory: {}
+          };
+          cachedAllData = responsePayload;
+          cachedAllTimestamp = now;
+          sendJson(res, 200, responsePayload);
+          return true;
+        }
+        if (pathname === "/api/planning/metas") {
+          const tickets = await storage.listTickets({});
+          const metasMap = {};
+          for (const t of tickets) {
+            metasMap[String(t.meta.id)] = t.meta;
+          }
+          sendJson(res, 200, metasMap);
+          return true;
+        }
+        if (pathname === "/api/planning/details") {
+          const tickets = await storage.listTickets({});
+          const detailsMap = {};
+          for (const t of tickets) {
+            if (t.detail?.raw) {
+              detailsMap[String(t.meta.id)] = t.detail.raw;
+            }
+          }
+          sendJson(res, 200, detailsMap);
+          return true;
+        }
+        if (pathname === "/api/planning/plans") {
+          const tickets = await storage.listTickets({});
+          const plansMap = {};
+          for (const t of tickets) {
+            if (t.planMarkdown) {
+              plansMap[String(t.meta.id)] = t.planMarkdown;
+            }
+          }
+          sendJson(res, 200, plansMap);
+          return true;
+        }
+        if (pathname === "/api/planning/comments") {
+          const tickets = await storage.listTickets({});
+          const commentsMap = {};
+          for (const t of tickets) {
+            commentsMap[String(t.meta.id)] = t.comments || [];
+          }
+          sendJson(res, 200, commentsMap);
+          return true;
+        }
+        if (pathname === "/api/planning/history") {
+          sendJson(res, 200, {});
+          return true;
+        }
+        if (pathname === "/api/planning/inline-comments") {
+          sendJson(res, 200, {});
+          return true;
+        }
+        if (pathname === "/api/planning/answers") {
+          sendJson(res, 200, {});
+          return true;
+        }
+        if (pathname === "/api/planning/plan-history") {
+          sendJson(res, 200, {});
+          return true;
+        }
+        if (pathname === "/api/planning/snapshot") {
+          const projectCode = url.searchParams.get("project");
+          if (!projectCode) {
+            sendJson(res, 400, { error: "Project query parameter is required for snapshot generation (no default fallback)." });
+            return true;
+          }
+          const snapshot = await generateProjectSnapshot(storage, projectCode, workspaceRoot);
+          sendJson(res, 200, snapshot);
+          return true;
+        }
+      }
+      if (req.method === "POST") {
+        const body = await readJsonBody(req);
+        if (pathname === "/api/planning/tickets") {
+          invalidateApiCache();
+          const created = await storage.createTicket(body);
+          sendJson(res, 201, { ticketId: String(created.meta.id), meta: created.meta });
+          return true;
+        }
+        if (pathname === "/api/planning/create-project") {
+          const { code, name, description, colors: colors2 } = body;
+          if (!code || !name) {
+            sendJson(res, 400, { error: "Both code and name are required to register a project." });
+            return true;
+          }
+          const codeVal = validateProjectCode(code);
+          if (!codeVal.valid) {
+            sendJson(res, 400, { error: codeVal.error });
+            return true;
+          }
+          invalidateApiCache();
+          const project = await storage.registerProject({
+            code,
+            name,
+            description,
+            colors: colors2
+          });
+          sendJson(res, 201, project);
+          return true;
+        }
+        if (pathname === "/api/planning/plans") {
+          const { ticketId, planMarkdown, lastHash } = body;
+          invalidateApiCache();
+          await storage.savePlan(ticketId, planMarkdown, lastHash);
+          sendJson(res, 200, { success: true });
+          return true;
+        }
+        if (pathname === "/api/planning/comments") {
+          const { ticketId, text, author } = body;
+          invalidateApiCache();
+          await storage.addComment(ticketId, { author: author || "Developer", text });
+          const ticket = await storage.getTicket(ticketId);
+          sendJson(res, 200, { comments: ticket?.comments || [] });
+          return true;
+        }
+        if (pathname === "/api/planning/update-meta") {
+          const { ticketId, updates, lastHash } = body;
+          const updated = await storage.updateTicket(ticketId, updates, lastHash);
+          sendJson(res, 200, { meta: updated.meta });
+          return true;
+        }
+        if (pathname === "/api/planning/toggle-flag") {
+          const { ticketId, flagged } = body;
+          const updated = await storage.updateTicket(ticketId, {
+            featureFlag: flagged ? "chat_enhanced" : ""
+          });
+          sendJson(res, 200, { meta: updated.meta });
+          return true;
+        }
+        if (pathname === "/api/planning/details") {
+          const { ticketId, detailMarkdown, metaUpdates } = body;
+          if (metaUpdates) {
+            await storage.updateTicket(ticketId, metaUpdates);
+          }
+          sendJson(res, 200, { success: true, detail: detailMarkdown });
+          return true;
+        }
+      }
+      sendJson(res, 404, { error: `Endpoint not found: ${pathname}` });
+      return true;
+    } catch (err) {
+      console.error("[Esedre API Error]:", err);
+      sendJson(res, 500, { error: err.message });
+      return true;
+    }
+  };
+}
+function startApiServer(port, storage, workspaceRoot) {
+  const handler = createApiHandler(storage, workspaceRoot);
+  const server = http3.createServer(async (req, res) => {
+    const handled = await handler(req, res);
+    if (!handled && !res.headersSent) {
+      sendJson(res, 404, { error: `Endpoint not found: ${req.url}` });
+    }
+  });
+  server.listen(port, "127.0.0.1", () => {
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`\x1B[31mError: Internal API port ${port} is already in use.\x1B[0m`);
+    } else {
+      console.error(`\x1B[31mAPI Server Error: ${err.message}\x1B[0m`);
+    }
+  });
+  return server;
+}
+
+// src/server/gateway.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path7.dirname(__filename2);
+function resolveWebDir(explicitWebDir, workspaceRoot) {
+  if (explicitWebDir && fs7.existsSync(path7.join(explicitWebDir, "index.html"))) {
+    return explicitWebDir;
+  }
+  const candidates = [
+    // 1. Packaged layout right next to executable (e.g. tools/web)
+    path7.resolve(__dirname2, "web"),
+    // 2. From workspace root: <workspaceRoot>/dist/web
+    workspaceRoot ? path7.resolve(workspaceRoot, "dist", "web") : "",
+    // 3. In-repo legacy subfolder: <workspaceRoot>/esedre/dist/web
+    workspaceRoot ? path7.resolve(workspaceRoot, "esedre", "dist", "web") : "",
+    // 4. Sibling standalone repository from workspace root: <workspaceRoot>/../esedre/dist/web
+    workspaceRoot ? path7.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
+    // 5. Packaged layout inside dist/web
+    path7.resolve(__dirname2, "dist", "web"),
+    // 6. Sibling standalone repository from __dirname: <__dirname>/../../esedre/dist/web
+    path7.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
+    // 7. Source tree layout: esedre/src/server/ -> esedre/dist/web
+    path7.resolve(__dirname2, "..", "..", "dist", "web"),
+    // 8. Legacy layout from __dirname
+    path7.resolve(__dirname2, "..", "esedre", "dist", "web")
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if (fs7.existsSync(path7.join(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  return candidates[0] || path7.resolve(__dirname2, "web");
+}
+function proxyRequest(req, res, targetPort, rewritePath) {
+  const targetPath = rewritePath ? rewritePath(req.url || "/") : req.url || "/";
+  const options = {
+    hostname: "127.0.0.1",
+    port: targetPort,
+    path: targetPath,
+    method: req.method,
+    headers: {
+      ...req.headers,
+      host: `127.0.0.1:${targetPort}`,
+      "x-forwarded-for": req.socket.remoteAddress || "",
+      "x-forwarded-proto": "http"
+    }
+  };
+  const proxyReq = http4.request(options, (proxyRes) => {
+    res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+    proxyRes.pipe(res, { end: true });
+  });
+  proxyReq.on("error", (err) => {
+    console.error(`[Gateway Proxy Error -> ${targetPort}]:`, err.message);
+    if (!res.headersSent) {
+      res.writeHead(502, { "Content-Type": "text/plain" });
+      res.end(`Bad Gateway: Could not forward request to internal port ${targetPort}`);
+    }
+  });
+  req.pipe(proxyReq, { end: true });
+}
+function startGatewayCluster(options) {
+  const gatewayPort = options.gatewayPort !== void 0 ? options.gatewayPort : 5674;
+  const uiPort = options.uiPort !== void 0 ? options.uiPort : gatewayPort ? gatewayPort + 1 : 0;
+  const apiPort = options.apiPort !== void 0 ? options.apiPort : gatewayPort ? gatewayPort + 2 : 0;
+  const webDir = resolveWebDir(options.webDir, options.workspaceRoot);
+  const uiServer = startUiServer(uiPort, webDir);
+  const apiServer = startApiServer(apiPort, options.storage, options.workspaceRoot);
+  const getUiPort = () => uiServer.address()?.port || uiPort;
+  const getApiPort = () => apiServer.address()?.port || apiPort;
+  const gatewayServer = http4.createServer((req, res) => {
+    const rawUrl = req.url || "/";
+    const parsedPath = rawUrl.split("?")[0];
+    if (parsedPath === "/" || parsedPath === "/index.html" || parsedPath === "/esedre" || parsedPath === "/esedre/") {
+      const search = rawUrl.includes("?") ? rawUrl.slice(rawUrl.indexOf("?")) : "";
+      proxyRequest(req, res, getUiPort(), () => `/app/${search}`);
+      return;
+    }
+    if (parsedPath.startsWith("/api") || parsedPath.startsWith("/esedre/api")) {
+      proxyRequest(req, res, getApiPort(), (p) => {
+        return p.replace(/^\/esedre\/api/, "/api");
+      });
+      return;
+    }
+    if (parsedPath.startsWith("/app") || parsedPath.startsWith("/esedre/app") || parsedPath.startsWith("/assets/")) {
+      proxyRequest(req, res, getUiPort(), (p) => {
+        return p.replace(/^\/esedre\/app/, "/app");
+      });
+      return;
+    }
+    proxyRequest(req, res, getUiPort());
+  });
+  gatewayServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`\x1B[31mError: Port ${gatewayPort} is already in use by another process.\x1B[0m`);
+    } else {
+      console.error(`\x1B[31mGateway Server Error: ${err.message}\x1B[0m`);
+    }
+  });
+  gatewayServer.listen(gatewayPort, "0.0.0.0", () => {
+  });
+  return {
+    gatewayServer,
+    uiServer,
+    apiServer,
+    close: async () => {
+      await Promise.all([
+        new Promise((resolve) => gatewayServer.close(resolve)),
+        new Promise((resolve) => uiServer.close(resolve)),
+        new Promise((resolve) => apiServer.close(resolve))
+      ]);
+    }
+  };
+}
+
+// bin/esedre.ts
+function printHelp() {
+  console.log(`
+${colors.bold}${colors.cyan}Esedre CLI (/eh-seh-dreh/)${colors.reset}: Developer Roadmap & Companion LLM Coordination Engine
+
+${colors.bold}USAGE:${colors.reset}
+  .esedre/esedre <command> [options]
+  .esedre/ese <command> [options]
+  esedre <command> [options]
+  ese <command> [options]
+  node tools/esedre.mjs <command> [options]
+
+${colors.bold}COMMANDS:${colors.reset}
+  ${colors.bold}list${colors.reset}        [-p|--project <code|all>] [-s|--status <status>] [-t|--type <type>] [-q|--search <q>] [--json]
+               List roadmap tickets with optional filters (defaults to active project).
+               \u2022 Status values: 'Planned', 'In Development', 'Completed', 'Rejected'
+               \u2022 Type values:   'Feature', 'Platform', 'Tools', 'Idea', 'Bug'
+
+  ${colors.bold}get${colors.reset}         <id> [--json]
+               Inspect full ticket specification, feature breakdown, and comments.
+
+  ${colors.bold}plan${colors.reset}        <id> [--file <path> | --set "<markdown>"] [--last-hash <sha1>] [--json]
+               View or update implementation plan with optimistic concurrency control.
+
+  ${colors.bold}create${colors.reset}      --title "..." [-p|--project <code>] [-t|--type <type>] [--complexity <c>] [--effort "<e>"] [--summary "<s>"] [--json]
+               Mint a new roadmap ticket with sequential numeric ID.
+
+  ${colors.bold}update${colors.reset}      <id> [-s|--status <status>] [--title "..."] [--flag] [--no-flag] [--last-hash <sha1>] [--force] [--json]
+               Mutate ticket status, title, active state, or feature flag with OCC protection.
+
+  ${colors.bold}comment${colors.reset}     <id> --text "..." [--author "..."] [--json]
+               Append a research finding, test verification, or note to ticket history.
+
+  ${colors.bold}snapshot${colors.reset}    [--project <code>] [--json]
+               Generate lean read-only projection snapshot (.esedre/snapshot.json) for zero-latency agent context.
+
+  ${colors.bold}configure${colors.reset}   [--project <code>] [-n|--name <name>] [--allow <c1,c2>] [--port <n>] [--no-mcp] [--proxy] [--no-proxy] [-y|--yes] [--json]
+               Initialize or update .esedre footprint, register project code & display name in Esedre,
+               plant wrappers (.esedre/esedre.cmd, .esedre/ese.cmd, etc.), configure .gitignore,
+               MCP server config, agent skill templates, and display guided next steps.
+
+  ${colors.bold}upgrade${colors.reset}     [--json]
+               Upgrade workspace configuration schema, wrappers, and agent skills. Refreshes snapshot.
+
+  ${colors.bold}projects${colors.reset}    [--json]
+               List registered workspace projects, project codes (e.g. 'CORE', 'WEB', 'DOCS'), and descriptions.
+
+  ${colors.bold}daemon${colors.reset}      [start|stop|status|logs] [--port <n>] [--quiet] [--json]
+               Manage background daemon process (start, stop, check status, or view logs).
+
+  ${colors.bold}serve${colors.reset}       [--port <n>]
+               Run the unified gateway & web server in foreground (default 5674).
+
+  ${colors.bold}start${colors.reset}       [--port <n>] [--quiet] [--json]
+               Alias for 'daemon start'. Start Esedre background daemon process.
+
+  ${colors.bold}stop${colors.reset}        [--port <n>] [--quiet] [--json]
+               Alias for 'daemon stop'. Stop the running Esedre background daemon process.
+
+  ${colors.bold}status${colors.reset}      [--port <n>] [--json]
+               Alias for 'daemon status'. Check health and diagnostics of the daemon process.
+
+  ${colors.bold}logs${colors.reset}        [--port <n>] [--lines <n>]
+               Tail recent output logs from the Esedre daemon process.
+
+  ${colors.bold}mcp${colors.reset}         Start the Model Context Protocol (MCP) JSON-RPC 2.0 stdio server for autonomous LLM coding agents.
+
+${colors.bold}OPTIONS:${colors.reset}
+  -p, --project <code> Project code (e.g. CORE, ALCE, DOCS).
+  -n, --name <name>    Project display name (e.g. "Alce Web Reader").
+  -t, --type <type>    Ticket type ('Feature', 'Platform', 'Tools', 'Idea', 'Bug').
+  -s, --status <stat>  Ticket status ('Planned', 'In Development', 'Completed', 'Rejected').
+  -q, --search <query> Case-insensitive substring search query.
+  --json              Output raw machine-readable JSON (strongly recommended for autonomous LLM coding agents).
+  --last-hash <hash>  Optimistic concurrency control: last known sha1 hash of the ticket from 'get'.
+  --force             Bypass optimistic concurrency last-hash conflict checks on writes.
+  -h, --help          Show this help reference.
+
+${colors.bold}TYPICAL AGENT WORKFLOW:${colors.reset}
+  1. Inspect active tickets:  ese list --status "In Development" --json
+  2. Inspect ticket spec:     ese get 96 --json
+  3. Update plan markdown:    ese plan 96 --file plan.md --last-hash <sha1>
+  4. Complete ticket:         ese update 96 --status "Completed" --last-hash <sha1>
+  5. Add verification note:   ese comment 96 --text "Verified tests pass." --author "Agent"
+  * Tip: Read .esedre/snapshot.json directly for zero-latency roadmap context without subprocess execution.
+`);
+}
+function parseArgs(rawArgs) {
+  const positionals = [];
+  const flags = {};
+  let command = "";
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = rawArgs[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      if (key === "h") {
+        flags["help"] = true;
+      } else if (key === "y") {
+        flags["yes"] = true;
+      } else if (key === "t" || key === "p" || key === "s" || key === "q" || key === "n") {
+        const next = rawArgs[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      if (!command) {
+        command = arg;
+      } else {
+        positionals.push(arg);
+      }
+    }
+  }
+  if (flags["t"] && !flags["type"]) flags["type"] = flags["t"];
+  if (flags["p"] && !flags["project"]) flags["project"] = flags["p"];
+  if (flags["n"] && !flags["name"]) flags["name"] = flags["n"];
+  if (flags["s"] && !flags["status"]) flags["status"] = flags["s"];
+  if (flags["q"] && !flags["search"]) flags["search"] = flags["q"];
+  return { command, positionals, flags };
+}
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  const { command, positionals, flags } = parseArgs(rawArgs);
+  if (!command || flags["help"] || flags["h"]) {
+    printHelp();
+    return;
+  }
+  const isJson = Boolean(flags["json"]);
+  const discovered = findEsedreConfig(process.cwd());
+  const rawStorage = new FilesystemStorageAdapter(discovered.workspaceRoot, discovered.config);
+  const storage = new SecurityFilter(rawStorage, discovered.config);
+  try {
+    switch (command) {
+      case "configure": {
+        let projectCode = flags["project"] || flags["p"] || discovered.config?.projectCode;
+        let projectName = flags["name"] || flags["n"] || discovered.config?.projectName;
+        const allowArg = flags["allow"];
+        const port = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const setupMcp = flags["no-mcp"] ? false : true;
+        const isYes = Boolean(flags["yes"] || flags["y"]);
+        if (process.stdin.isTTY && (!projectCode || !projectName) && !isJson) {
+          const readline2 = await import("node:readline/promises");
+          const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+          try {
+            if (!projectCode) {
+              const codeAnswer = await rl.question(
+                `${colors.cyan}?${colors.reset} Project code (1-6 alphanumeric characters, e.g. ALCE, DOCS): `
+              );
+              projectCode = codeAnswer.trim();
+            }
+            if (!projectName && projectCode) {
+              const nameAnswer = await rl.question(
+                `${colors.cyan}?${colors.reset} Project display name (e.g. ${projectCode} App) [${projectCode}]: `
+              );
+              projectName = nameAnswer.trim() || projectCode;
+            }
+          } finally {
+            rl.close();
+          }
+        }
+        if (!projectCode) {
+          console.error(`${colors.red}Error: Project code is required (--project <code>, -p <code>, or configure projectCode in esedre.json).${colors.reset}`);
+          process.exit(1);
+        }
+        const codeVal = validateProjectCode(projectCode);
+        if (!codeVal.valid) {
+          console.error(`${colors.red}Error: ${codeVal.error}${colors.reset}`);
+          process.exit(1);
+        }
+        if (!projectName) {
+          projectName = projectCode;
+        }
+        const existingProjects = await storage.getProjects();
+        const existing = existingProjects.find(
+          (p) => p.code.toLowerCase() === projectCode.toLowerCase()
+        );
+        let projectNewlyRegistered = false;
+        let registeredProj;
+        if (!existing) {
+          registeredProj = await rawStorage.registerProject({
+            code: projectCode,
+            name: projectName
+          });
+          projectNewlyRegistered = true;
+        } else {
+          registeredProj = existing;
+          if (flags["name"] || flags["n"]) {
+            registeredProj = await rawStorage.registerProject({
+              code: projectCode,
+              name: projectName
+            });
+          }
+        }
+        const allowedProjects = allowArg ? allowArg.split(",").map((s) => s.trim()) : discovered.config?.allowedProjects || [projectCode];
+        let setupProxy = void 0;
+        if (flags["proxy"] !== void 0) {
+          setupProxy = Boolean(flags["proxy"]);
+        } else if (flags["no-proxy"] !== void 0) {
+          setupProxy = false;
+        }
+        const viteConfigPath = findViteConfig(discovered.workspaceRoot);
+        if (viteConfigPath && setupProxy === void 0 && !isJson) {
+          try {
+            const rawContent = fs8.readFileSync(viteConfigPath, "utf-8");
+            const alreadyConfigured = rawContent.includes("'/esedre'") || rawContent.includes('"/esedre"');
+            if (!alreadyConfigured) {
+              if (isYes) {
+                setupProxy = true;
+              } else if (process.stdin.isTTY) {
+                const readline2 = await import("node:readline/promises");
+                const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+                try {
+                  const answer = await rl.question(
+                    `${colors.cyan}?${colors.reset} Detected ${colors.bold}${path8.basename(viteConfigPath)}${colors.reset}. Would you like to configure a reverse proxy for ${colors.bold}/esedre${colors.reset} targeting http://127.0.0.1:${port}? [Y/n] `
+                  );
+                  const trimmed = answer.trim().toLowerCase();
+                  setupProxy = trimmed === "" || trimmed === "y" || trimmed === "yes";
+                } finally {
+                  rl.close();
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        const res = configureWorkspace(discovered.workspaceRoot, {
+          projectCode,
+          projectName: registeredProj.name,
+          allowedProjects,
+          port,
+          setupMcp,
+          setupProxy
+        });
+        let snapshotTickets = 0;
+        try {
+          const snapshot = await generateProjectSnapshot(storage, projectCode, discovered.workspaceRoot);
+          snapshotTickets = snapshot.totalTickets;
+        } catch {
+        }
+        if (isJson) {
+          console.log(JSON.stringify({
+            ...res,
+            project: registeredProj,
+            projectNewlyRegistered,
+            snapshotTickets,
+            urls: {
+              ui: `http://localhost:${port}/app?project=${projectCode}`,
+              portfolio: `http://localhost:${port}/app?project=all`,
+              api: `http://localhost:${port}/api`
+            },
+            commands: {
+              start: "ese start",
+              status: "ese status",
+              stop: "ese stop",
+              create: `ese create --title "..." --project ${projectCode}`,
+              list: `ese list --project ${projectCode}`
+            }
+          }, null, 2));
+        } else {
+          console.log(`${colors.bold}${colors.green}\u2714 Esedre workspace configured successfully!${colors.reset}`);
+          console.log(`  \u2022 Config: .esedre/esedre.json (Project: ${projectCode} (${registeredProj.name}), Version: ${CURRENT_ESEDRE_VERSION})`);
+          if (projectNewlyRegistered) {
+            console.log(`  \u2022 Project: ${colors.green}Registered new project '${projectCode}' (${registeredProj.name}) in Esedre${colors.reset}`);
+          } else {
+            console.log(`  \u2022 Project: Verified project '${projectCode}' (${registeredProj.name}) in Esedre`);
+          }
+          console.log(`  \u2022 In-repo wrappers: .esedre/esedre.cmd, .esedre/ese.cmd, .esedre/esedre, .esedre/ese`);
+          console.log(`  \u2022 .gitignore: ${res.gitignoreUpdated ? "Added .esedre/snapshot.json" : "Already configured"}`);
+          console.log(`  \u2022 Snapshot: Generated .esedre/snapshot.json (${snapshotTickets} tickets projected)`);
+          console.log(`  \u2022 MCP: ${res.mcpConfigured ? "Configured in .agents/mcp_config.json" : "Skipped"}`);
+          console.log(`  \u2022 Skill: ${res.skillConfigured ? "Updated .agents/skills/esedre/SKILL.md" : `Retained (${res.skillStatus})`}`);
+          if (res.globalStoreStatus === "ready") {
+            console.log(`  \u2022 Global Store: ${res.globalStorePath} (verified write permissions)`);
+          } else if (res.globalStoreStatus === "warning") {
+            console.log(`  \u2022 ${colors.yellow}Global Store: Fallback to ${res.globalStorePath} (${res.globalStoreError})${colors.reset}`);
+          }
+          if (res.viteProxyStatus === "CONFIGURED") {
+            console.log(`  \u2022 ${colors.green}Vite Proxy: Added /esedre proxy to ${res.viteConfigFile} targeting http://127.0.0.1:${port}${colors.reset}`);
+          } else if (res.viteProxyStatus === "ALREADY_CONFIGURED") {
+            console.log(`  \u2022 Vite Proxy: /esedre is already configured in ${res.viteConfigFile}`);
+          } else if (res.viteProxyStatus === "SKIPPED") {
+            console.log(`  \u2022 Vite Proxy: Skipped configuring ${res.viteConfigFile}`);
+            console.log(`
+${colors.bold}Recommendation:${colors.reset} To embed the dev planner within your UI, add this proxy to ${res.viteConfigFile}:`);
+            console.log(colors.dim + (res.recommendedProxySnippet?.split("\n").map((l) => "    " + l).join("\n") || "") + colors.reset);
+          } else if (res.viteProxyStatus === "NOT_APPLICABLE") {
+            console.log(`
+${colors.bold}Recommendation:${colors.reset} If you wish to embed the dev planner within your project's UI, configure a reverse proxy for '/esedre' targeting http://127.0.0.1:${port}:`);
+            console.log(colors.dim + (res.recommendedProxySnippet?.split("\n").map((l) => "    " + l).join("\n") || "") + colors.reset);
+          } else if (res.viteProxyStatus === "MANUAL_REQUIRED") {
+            console.log(`  \u2022 ${colors.yellow}Vite Proxy: Could not automatically inject proxy into ${res.viteConfigFile}.${colors.reset}`);
+            console.log(`
+${colors.bold}Recommendation:${colors.reset} Please manually add this proxy to your dev server configuration:`);
+            console.log(colors.dim + (res.recommendedProxySnippet?.split("\n").map((l) => "    " + l).join("\n") || "") + colors.reset);
+          }
+          console.log(`
+${colors.bold}Next Steps:${colors.reset}`);
+          console.log(`  1. ${colors.bold}Start the background daemon:${colors.reset}`);
+          console.log(`     ${colors.cyan}ese start${colors.reset}   (or: ${colors.dim}.esedre/ese start${colors.reset})`);
+          console.log(`
+  2. ${colors.bold}Open the visual Web UI:${colors.reset}`);
+          console.log(`     ${colors.cyan}http://localhost:${port}/app?project=${projectCode}${colors.reset}`);
+          if (res.viteProxyStatus === "CONFIGURED" || res.viteProxyStatus === "ALREADY_CONFIGURED") {
+            console.log(`     ${colors.dim}Embedded via host dev server:${colors.reset} http://localhost:5173/esedre/app?project=${projectCode}`);
+          }
+          console.log(`
+  3. ${colors.bold}Create your first ticket:${colors.reset}`);
+          console.log(`     ${colors.cyan}ese create --title "First feature" --type Feature --project ${projectCode}${colors.reset}`);
+          console.log(`
+  4. ${colors.bold}Inspect roadmap & tickets:${colors.reset}`);
+          console.log(`     ${colors.cyan}ese list --project ${projectCode}${colors.reset}`);
+        }
+        return;
+      }
+      case "upgrade": {
+        const res = configureWorkspace(discovered.workspaceRoot, {
+          projectCode: discovered.config?.projectCode,
+          allowedProjects: discovered.config?.allowedProjects,
+          port: discovered.config?.port
+        });
+        const projectCode = discovered.config?.projectCode;
+        if (!projectCode) {
+          console.error(`${colors.red}Error: "projectCode" is required in esedre.json configuration (no default fallback).${colors.reset}`);
+          process.exit(1);
+        }
+        const snapshot = await generateProjectSnapshot(storage, projectCode, discovered.workspaceRoot);
+        if (isJson) {
+          console.log(JSON.stringify({ upgrade: res, snapshot: { totalTickets: snapshot.totalTickets } }, null, 2));
+        } else {
+          console.log(`${colors.bold}${colors.green}\u2714 Esedre upgrade completed!${colors.reset}`);
+          console.log(`  \u2022 Esedre Engine Version: ${CURRENT_ESEDRE_VERSION}`);
+          console.log(`  \u2022 Wrappers updated in .esedre/`);
+          console.log(`  \u2022 Refreshed .esedre/snapshot.json (${snapshot.totalTickets} tickets projected)`);
+          if (res.skillStatus === "CUSTOMIZED") {
+            console.log(`  \u2022 ${colors.yellow}Notice: .agents/skills/esedre/SKILL.md is customized; preserved user modifications.${colors.reset}`);
+          }
+        }
+        return;
+      }
+      case "snapshot": {
+        const projectCode = flags["project"] || discovered.config?.projectCode;
+        if (!projectCode) {
+          console.error(`${colors.red}Error: Project code is required (--project <code> or configure projectCode in esedre.json).${colors.reset}`);
+          process.exit(1);
+        }
+        const snapshot = await generateProjectSnapshot(storage, projectCode, discovered.workspaceRoot);
+        if (isJson) {
+          console.log(JSON.stringify(snapshot, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Generated projection snapshot for project '${projectCode}'${colors.reset}`);
+          console.log(`  \u2022 Location: .esedre/snapshot.json`);
+          console.log(`  \u2022 Tickets: ${snapshot.totalTickets}`);
+          console.log(`  \u2022 Timestamp: ${snapshot.generatedAt}`);
+        }
+        return;
+      }
+      case "mcp": {
+        const mcpServer = new EsedreMcpServer(storage);
+        mcpServer.start();
+        return;
+      }
+      case "start": {
+        const port = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const quiet = Boolean(flags["quiet"] || isJson);
+        const state = await startDaemon({ port, quiet, workspaceRoot: discovered.workspaceRoot });
+        if (isJson) {
+          console.log(JSON.stringify(state, null, 2));
+        }
+        return;
+      }
+      case "stop": {
+        const port = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const quiet = Boolean(flags["quiet"] || isJson);
+        const stopped = await stopDaemon({ port, quiet, workspaceRoot: discovered.workspaceRoot });
+        if (isJson) {
+          console.log(JSON.stringify({ port, stopped }, null, 2));
+        }
+        return;
+      }
+      case "status": {
+        const port = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const status = await getDaemonStatus({ port, workspaceRoot: discovered.workspaceRoot });
+        if (isJson) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          if (status.running) {
+            console.log(`${colors.bold}${colors.green}\u25CF Esedre daemon is RUNNING${colors.reset}`);
+            console.log(`  \u2022 Port:        ${status.port}`);
+            if (status.pid) console.log(`  \u2022 PID:         ${status.pid}`);
+            if (status.uptimeSeconds !== void 0) console.log(`  \u2022 Uptime:      ${status.uptimeSeconds}s`);
+            if (status.startedAt) console.log(`  \u2022 Started:     ${status.startedAt}`);
+            if (status.projects?.length) console.log(`  \u2022 Projects:    ${status.projects.join(", ")}`);
+            if (status.logFile) console.log(`  \u2022 Logs:        ${status.logFile}`);
+          } else {
+            console.log(`${colors.yellow}\u25CB Esedre daemon is STOPPED (port ${status.port})${colors.reset}`);
+            if (status.logFile && fs8.existsSync(status.logFile)) {
+              console.log(`  \u2022 Recent Logs: ${status.logFile}`);
+            }
+          }
+        }
+        return;
+      }
+      case "logs": {
+        const port = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const lines = flags["lines"] ? parseInt(String(flags["lines"]), 10) : 40;
+        printDaemonLogs({ port, lines, workspaceRoot: discovered.workspaceRoot });
+        return;
+      }
+      case "serve": {
+        const gatewayPort = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const cluster = startGatewayCluster({
+          gatewayPort,
+          uiPort: gatewayPort + 1,
+          apiPort: gatewayPort + 2,
+          storage,
+          workspaceRoot: discovered.workspaceRoot
+        });
+        console.log(`${colors.bold}${colors.green}\u2714 Esedre Server active on http://localhost:${gatewayPort}${colors.reset}`);
+        console.log(`  \u2022 Web UI:      http://localhost:${gatewayPort}/app (internal: ${gatewayPort + 1})`);
+        console.log(`  \u2022 REST API:    http://localhost:${gatewayPort}/api (internal: ${gatewayPort + 2})`);
+        console.log(`  \u2022 Rewrite /:   http://localhost:${gatewayPort}/ -> http://localhost:${gatewayPort}/app/`);
+        console.log(`  \u2022 Portfolio:   http://localhost:${gatewayPort}/app?project=all`);
+        console.log(`  \u2022 Press Ctrl+C to stop.`);
+        process.on("SIGINT", async () => {
+          console.log(`
+${colors.dim}Shutting down Esedre cluster...${colors.reset}`);
+          await cluster.close();
+          process.exit(0);
+        });
+        return;
+      }
+      case "daemon": {
+        const sub = positionals[0] || "status";
+        const port = flags["port"] ? parseInt(String(flags["port"]), 10) : discovered.config?.port || 5674;
+        const quiet = Boolean(flags["quiet"] || isJson);
+        if (sub === "start") {
+          const state = await startDaemon({ port, quiet, workspaceRoot: discovered.workspaceRoot });
+          if (isJson) console.log(JSON.stringify(state, null, 2));
+          return;
+        } else if (sub === "stop") {
+          const stopped = await stopDaemon({ port, quiet, workspaceRoot: discovered.workspaceRoot });
+          if (isJson) console.log(JSON.stringify({ port, stopped }, null, 2));
+          return;
+        } else if (sub === "status") {
+          const status = await getDaemonStatus({ port, workspaceRoot: discovered.workspaceRoot });
+          if (isJson) {
+            console.log(JSON.stringify(status, null, 2));
+          } else {
+            if (status.running) {
+              console.log(`${colors.bold}${colors.green}\u25CF Esedre daemon is RUNNING${colors.reset}`);
+              console.log(`  \u2022 Port:        ${status.port}`);
+              if (status.pid) console.log(`  \u2022 PID:         ${status.pid}`);
+              if (status.uptimeSeconds !== void 0) console.log(`  \u2022 Uptime:      ${status.uptimeSeconds}s`);
+              if (status.startedAt) console.log(`  \u2022 Started:     ${status.startedAt}`);
+              if (status.projects?.length) console.log(`  \u2022 Projects:    ${status.projects.join(", ")}`);
+              if (status.logFile) console.log(`  \u2022 Logs:        ${status.logFile}`);
+            } else {
+              console.log(`${colors.yellow}\u25CB Esedre daemon is STOPPED (port ${status.port})${colors.reset}`);
+              if (status.logFile && fs8.existsSync(status.logFile)) {
+                console.log(`  \u2022 Recent Logs: ${status.logFile}`);
+              }
+            }
+          }
+          return;
+        } else if (sub === "logs") {
+          const logFile = path8.resolve(discovered.workspaceRoot || process.cwd(), ".esedre", "daemon.log");
+          if (fs8.existsSync(logFile)) {
+            console.log(fs8.readFileSync(logFile, "utf-8"));
+          } else {
+            console.log(`${colors.dim}No daemon log file found at ${logFile}${colors.reset}`);
+          }
+          return;
+        } else {
+          console.error(`${colors.red}Unknown daemon subcommand: '${sub}'. Expected 'start', 'stop', 'status', or 'logs'.${colors.reset}`);
+          process.exit(1);
+        }
+      }
+      case "projects": {
+        const projects = await storage.getProjects();
+        if (isJson) {
+          console.log(JSON.stringify(projects, null, 2));
+        } else {
+          console.log(`${colors.bold}Registered Projects:${colors.reset}`);
+          for (const p of projects) {
+            console.log(`  \u2022 ${colors.bold}${p.code}${colors.reset} (#${p.id}): ${p.name}: ${colors.dim}${p.description}${colors.reset}`);
+          }
+        }
+        return;
+      }
+      case "list": {
+        const rawProject = flags["project"];
+        const project = rawProject === "all" ? void 0 : rawProject || discovered.config?.projectCode || void 0;
+        const status = flags["status"] || void 0;
+        const type = flags["type"] || flags["category"] || void 0;
+        const category = type;
+        const search = flags["search"] || void 0;
+        const tickets = await storage.listTickets({ project, status, type, category, search });
+        if (isJson) {
+          console.log(JSON.stringify(tickets.map((t) => ({
+            id: t.meta.id,
+            title: t.meta.title,
+            type: t.meta.type || t.meta.category,
+            category: t.meta.type || t.meta.category,
+            status: t.meta.status,
+            complexity: t.meta.complexity,
+            effort: t.meta.estimatedEffort,
+            project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
+            sha1: t.sha1 || t.meta.sha1
+          })), null, 2));
+        } else {
+          console.log(formatTicketListTable(tickets));
+          console.log(`
+${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
+        }
+        return;
+      }
+      case "get": {
+        const idStr = positionals[0];
+        if (!idStr) {
+          console.error(`${colors.red}Error: Ticket ID is required (e.g. ese get 1 or ese get Profe-1)${colors.reset}`);
+          process.exit(1);
+        }
+        const projectFlag = flags["project"];
+        const lookupKey = projectFlag && /^\d+$/.test(idStr) ? `${projectFlag}-${idStr}` : idStr;
+        const ticket = await storage.getTicket(lookupKey);
+        if (!ticket) {
+          console.error(`${colors.red}Error: Ticket #${lookupKey} not found.${colors.reset}`);
+          process.exit(1);
+        }
+        if (isJson) {
+          console.log(JSON.stringify(ticket, null, 2));
+        } else {
+          console.log(formatTicketDetail(ticket));
+        }
+        return;
+      }
+      case "plan": {
+        const idStr = positionals[0];
+        if (!idStr) {
+          console.error(`${colors.red}Error: Ticket ID is required (e.g. ese plan 1 or ese plan Profe-1)${colors.reset}`);
+          process.exit(1);
+        }
+        const projectFlag = flags["project"];
+        const id = projectFlag && /^\d+$/.test(idStr) ? `${projectFlag}-${idStr}` : idStr;
+        const setPlan = flags["set"];
+        const filePath = flags["file"];
+        const isForce = Boolean(flags["force"]);
+        const lastHash = isForce ? void 0 : flags["last-hash"];
+        if (setPlan || filePath) {
+          let content = setPlan;
+          if (filePath) {
+            if (!fs8.existsSync(filePath)) {
+              console.error(`${colors.red}Error: Plan file "${filePath}" not found.${colors.reset}`);
+              process.exit(1);
+            }
+            content = fs8.readFileSync(filePath, "utf-8");
+          }
+          await storage.savePlan(id, content, lastHash);
+          console.log(`${colors.green}\u2714 Implementation plan saved for Ticket #${id}${colors.reset}`);
+          return;
+        }
+        const plan = await storage.getPlan(id);
+        if (!plan) {
+          console.log(`${colors.dim}No implementation plan found for Ticket #${id}.${colors.reset}`);
+          return;
+        }
+        if (isJson) {
+          console.log(JSON.stringify({ ticketId: id, planMarkdown: plan }, null, 2));
+        } else {
+          console.log(plan);
+        }
+        return;
+      }
+      case "create": {
+        const title = flags["title"];
+        if (!title) {
+          console.error(`${colors.red}Error: --title is required${colors.reset}`);
+          process.exit(1);
+        }
+        const type = flags["type"] || flags["category"] || "Feature";
+        const category = type;
+        const projectCode = flags["project"] || discovered.config?.projectCode;
+        if (!projectCode) {
+          console.error(`${colors.red}Error: Project is required to create a ticket (--project <code> or configure projectCode in esedre.json).${colors.reset}`);
+          process.exit(1);
+        }
+        const complexity = flags["complexity"] || "Medium";
+        const estimatedEffort = flags["effort"] || "2.0 \u2013 4.0 hours";
+        const summary = flags["summary"] || void 0;
+        const submittedBy = flags["author"] || "Developer";
+        const val = validateProjectCode(projectCode);
+        if (!val.valid) {
+          console.error(`${colors.red}Error: ${val.error}${colors.reset}`);
+          process.exit(1);
+        }
+        const created = await storage.createTicket({
+          title,
+          type,
+          category,
+          projectCode,
+          complexity,
+          estimatedEffort,
+          summary,
+          submittedBy
+        });
+        if (isJson) {
+          console.log(JSON.stringify(created, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Created Ticket #${created.meta.id}: ${created.meta.title}${colors.reset} [${created.projectDescriptor?.code || created.meta.project || "UNASSIGNED"}] (SHA-1: ${created.sha1?.slice(0, 8)})`);
+        }
+        return;
+      }
+      case "update": {
+        const idStr = positionals[0];
+        if (!idStr) {
+          console.error(`${colors.red}Error: Ticket ID is required (e.g. ese update 96 --status "Completed")${colors.reset}`);
+          process.exit(1);
+        }
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+          console.error(`${colors.red}Error: Invalid Ticket ID "${idStr}"${colors.reset}`);
+          process.exit(1);
+        }
+        const status = flags["status"];
+        const title = flags["title"];
+        const complexity = flags["complexity"];
+        const effort = flags["effort"];
+        const inDev = flags["in-dev"] !== void 0 ? Boolean(flags["in-dev"]) : void 0;
+        const flag = flags["flag"];
+        const isForce = Boolean(flags["force"]);
+        const lastHash = isForce ? void 0 : flags["last-hash"];
+        const updates = {};
+        const type = flags["type"] || flags["category"] || void 0;
+        if (type) {
+          updates.type = type;
+          updates.category = type;
+        }
+        if (status) updates.status = status;
+        if (title) updates.title = title;
+        if (complexity) updates.complexity = complexity;
+        if (effort) updates.estimatedEffort = effort;
+        if (inDev !== void 0) updates.isActivePlanning = inDev;
+        if (flag) updates.featureFlag = flag;
+        const updated = await storage.updateTicket(id, updates, lastHash);
+        if (isJson) {
+          console.log(JSON.stringify(updated, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Updated Ticket #${id}: ${updated.meta.title} (Status: ${updated.meta.status}, SHA-1: ${updated.sha1?.slice(0, 8)})${colors.reset}`);
+        }
+        return;
+      }
+      case "comment": {
+        const idStr = positionals[0];
+        if (!idStr) {
+          console.error(`${colors.red}Error: Ticket ID is required (e.g. ese comment 96 --text "...")`);
+          process.exit(1);
+        }
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+          console.error(`${colors.red}Error: Invalid Ticket ID "${idStr}"`);
+          process.exit(1);
+        }
+        const text = flags["text"];
+        if (!text) {
+          console.error(`${colors.red}Error: --text is required`);
+          process.exit(1);
+        }
+        const author = flags["author"] || "User";
+        const comment = await storage.addComment(id, { author, text });
+        if (isJson) {
+          console.log(JSON.stringify(comment, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Added comment to Ticket #${id} by ${comment.author}${colors.reset}`);
+        }
+        return;
+      }
+      default: {
+        console.error(`${colors.red}Error: Unknown command "${command}"${colors.reset}`);
+        printHelp();
+        process.exit(1);
+      }
+    }
+  } catch (err) {
+    if (err instanceof EsedreConflictError || err.name === "EsedreConflictError") {
+      console.error(`${colors.red}Conflict Error: ${err.message}${colors.reset}`);
+      console.error(`${colors.dim}Use --force to override if you are certain.${colors.reset}`);
+      process.exit(1);
+    }
+    if (err instanceof EsedreAuthorizationError || err.name === "EsedreAuthorizationError") {
+      console.error(`${colors.red}Access Denied: ${err.message}${colors.reset}`);
+      process.exit(1);
+    }
+    console.error(`${colors.red}Fatal Error: ${err.message}${colors.reset}`);
+    process.exit(1);
+  }
+}
+main();