esedre 1.0.1 → 1.1.0

package/dist/esedre.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // bin/esedre.ts
-import fs9 from "node:fs";
-import path9 from "node:path";
+import fs10 from "node:fs";
+import path10 from "node:path";
 
 // src/storage/filesystem.ts
 import fs3 from "node:fs";
@@ -10,7 +10,7 @@ import path3 from "node:path";
 import os2 from "node:os";
 
 // src/types.ts
-var CURRENT_ESEDRE_VERSION = "1.0.1";
+var CURRENT_ESEDRE_VERSION = "1.1.0";
 var INVERSE_RELATIONS = {
   "relates-to": "relates-to",
   "blocks": "blocked-by",
@@ -112,6 +112,16 @@ function getGlobalConfigDir() {
   if (process.env.ESEDRE_GLOBAL_DIR) {
     return process.env.ESEDRE_GLOBAL_DIR;
   }
+  if (process.env.VITEST) {
+    const testGlobalDir = path.join(os.tmpdir(), "esedre-vitest-global");
+    if (!fs.existsSync(testGlobalDir)) {
+      try {
+        fs.mkdirSync(testGlobalDir, { recursive: true });
+      } catch {
+      }
+    }
+    return testGlobalDir;
+  }
   return path.join(os.homedir(), ".esedre");
 }
 function getGlobalConfigPath() {
@@ -158,6 +168,35 @@ function writeGlobalVersion(version = CURRENT_ESEDRE_VERSION) {
   }
   fs.writeFileSync(getGlobalVersionPath(), version.trim() + "\n", "utf-8");
 }
+function hubContainsProject(hubPath, projectCodes) {
+  if (!hubPath || !projectCodes || projectCodes.length === 0) return false;
+  const resolved = path.resolve(expandHome(hubPath));
+  const projectsDir = path.join(resolved, "projects");
+  if (fs.existsSync(projectsDir)) {
+    try {
+      const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+      const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name.toLowerCase());
+      if (projectCodes.some((code) => dirNames.includes(code.trim().toLowerCase()))) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  const projectsJson = path.join(resolved, "projects.json");
+  if (fs.existsSync(projectsJson)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(projectsJson, "utf-8"));
+      if (Array.isArray(parsed)) {
+        const pCodes = parsed.map((p) => (p.code || "").trim().toLowerCase());
+        if (projectCodes.some((code) => pCodes.includes(code.trim().toLowerCase()))) {
+          return true;
+        }
+      }
+    } catch {
+    }
+  }
+  return false;
+}
 function addLocationToGlobalConfig(targetPath) {
   const resolved = path.resolve(expandHome(targetPath));
   if (!fs.existsSync(resolved)) {
@@ -337,8 +376,21 @@ function findEsedreConfig(startDir, options) {
   }
   const globalConfig = readGlobalConfig();
   if (localConfig) {
+    let inheritedDataDir = localConfig.dataDir;
+    if (inheritedDataDir === void 0 && globalConfig?.dataDir) {
+      const targetCodes = [
+        ...localConfig.projectCode ? [localConfig.projectCode] : [],
+        ...Array.isArray(localConfig.allowedProjects) ? localConfig.allowedProjects : []
+      ].filter((c) => c && c !== "*");
+      const globalDirs = Array.isArray(globalConfig.dataDir) ? globalConfig.dataDir : [globalConfig.dataDir];
+      const matchesGlobalHub = globalDirs.some((d) => hubContainsProject(d, targetCodes));
+      if (matchesGlobalHub) {
+        inheritedDataDir = globalConfig.dataDir;
+      }
+    }
     const merged = {
       ...localConfig,
+      dataDir: inheritedDataDir,
       port: localConfig.port !== void 0 ? localConfig.port : globalConfig?.port || DEFAULT_ESEDRE_PORT,
       ports: localConfig.ports || globalConfig?.ports
     };
@@ -655,6 +707,18 @@ function normalizeTicketFields(ticket) {
       if (c.author) c.author = normalizeDashesAndMojibake(c.author);
     }
   }
+  if (ticket.answers) {
+    for (const key of Object.keys(ticket.answers)) {
+      ticket.answers[key] = normalizeDashesAndMojibake(ticket.answers[key]);
+    }
+  }
+  if (ticket.inlineComments) {
+    for (const ic of ticket.inlineComments) {
+      if (ic.selectedText) ic.selectedText = normalizeDashesAndMojibake(ic.selectedText);
+      if (ic.comment) ic.comment = normalizeDashesAndMojibake(ic.comment);
+      if (ic.author) ic.author = normalizeDashesAndMojibake(ic.author);
+    }
+  }
   return ticket;
 }
 function formatTicketListTable(tickets) {
@@ -759,9 +823,12 @@ function formatTicketDetail(ticket) {
   if (detail?.openQuestions && detail.openQuestions.length > 0) {
     lines.push("");
     lines.push(`${colors.bold}Open Decisions & Questions:${colors.reset}`);
-    for (const q of detail.openQuestions) {
+    detail.openQuestions.forEach((q, idx) => {
       lines.push(`  \u2022 ${normalizeDashesAndMojibake(q)}`);
-    }
+      if (ticket.answers && ticket.answers[String(idx)]) {
+        lines.push(`    ${colors.green}> Answer:${colors.reset} ${normalizeDashesAndMojibake(ticket.answers[String(idx)])}`);
+      }
+    });
   }
   if (ticket.links && ticket.links.length > 0) {
     lines.push("");
@@ -883,13 +950,23 @@ function writeSafeFile(filePath, content) {
   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);
+    if (Buffer.isBuffer(content)) {
+      fs3.writeFileSync(tempPath, content);
+      fs3.renameSync(tempPath, filePath);
+    } else {
+      const normalized = content.replace(/\r\n/g, "\n");
+      fs3.writeFileSync(tempPath, normalized, "utf-8");
+      fs3.renameSync(tempPath, filePath);
+    }
   } catch {
-    fs3.writeFileSync(filePath, normalized, "utf-8");
+    if (Buffer.isBuffer(content)) {
+      fs3.writeFileSync(filePath, content);
+    } else {
+      const normalized = content.replace(/\r\n/g, "\n");
+      fs3.writeFileSync(filePath, normalized, "utf-8");
+    }
     if (fs3.existsSync(tempPath)) {
       try {
         fs3.unlinkSync(tempPath);
@@ -905,6 +982,23 @@ var FilesystemStorageAdapter = class {
   lastConfigCheck = 0;
   configTtlMs = 3e3;
   duplicateProjectWarnings = [];
+  milestoneMemoryCache = /* @__PURE__ */ new Map();
+  ticketMemoryCache = /* @__PURE__ */ new Map();
+  invalidateTicketCache(ticketDir) {
+    if (ticketDir) {
+      this.ticketMemoryCache.delete(path3.resolve(ticketDir));
+    } else {
+      this.ticketMemoryCache.clear();
+    }
+  }
+  invalidateMilestoneCache(loc) {
+    if (loc) {
+      const mPath = path3.resolve(this.getMilestonesPath(loc));
+      this.milestoneMemoryCache.delete(mPath);
+    } else {
+      this.milestoneMemoryCache.clear();
+    }
+  }
   getDuplicateProjectWarnings() {
     this.resolveProjectLocations();
     return [...this.duplicateProjectWarnings];
@@ -1803,6 +1897,8 @@ ${formattedList}`
         this.config.allowedProjects[idx] = cleanNew;
       }
     }
+    this.invalidateTicketCache();
+    this.invalidateMilestoneCache();
     this.refreshConfig();
     return {
       success: true,
@@ -1820,11 +1916,26 @@ ${formattedList}`
   }
   readProjectMilestones(loc) {
     const mPath = this.getMilestonesPath(loc);
-    if (!fs3.existsSync(mPath)) return [];
+    const resolvedPath = path3.resolve(mPath);
+    if (!fs3.existsSync(mPath)) {
+      this.milestoneMemoryCache.delete(resolvedPath);
+      return [];
+    }
     try {
+      const stat = fs3.statSync(mPath);
+      const cached = this.milestoneMemoryCache.get(resolvedPath);
+      if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        return cached.milestones;
+      }
       const raw = fs3.readFileSync(mPath, "utf-8");
       const parsed = JSON.parse(raw);
-      return Array.isArray(parsed) ? parsed : [];
+      const milestones = Array.isArray(parsed) ? parsed : [];
+      this.milestoneMemoryCache.set(resolvedPath, {
+        milestones,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size
+      });
+      return milestones;
     } catch {
       return [];
     }
@@ -1832,6 +1943,8 @@ ${formattedList}`
   writeProjectMilestones(loc, milestones) {
     const mPath = this.getMilestonesPath(loc);
     writeSafeFile(mPath, JSON.stringify(milestones, null, 2) + "\n");
+    this.invalidateMilestoneCache(loc);
+    this.invalidateTicketCache();
   }
   resolveMilestone(milestoneRef, localLoc) {
     const cleanRef = normalizeDashesAndMojibake(milestoneRef).trim();
@@ -2081,13 +2194,162 @@ ${formattedList}`
     }
     return null;
   }
+  readTicketFromDir(ticketDir, num, loc, locations, codeToDescriptor, idToDescriptor) {
+    const resolvedTicketDir = path3.resolve(ticketDir);
+    const filesToCheck = [
+      "meta.json",
+      "detail.md",
+      "implementation_plan.md",
+      "comments.json",
+      "answers.json",
+      "inline-comments.json"
+    ];
+    const currentStats = {};
+    for (const f of filesToCheck) {
+      const p = path3.join(ticketDir, f);
+      try {
+        const st = fs3.statSync(p);
+        currentStats[f] = { mtimeMs: st.mtimeMs, size: st.size };
+      } catch {
+      }
+    }
+    if (!currentStats["meta.json"]) return null;
+    const cached = this.ticketMemoryCache.get(resolvedTicketDir);
+    if (cached) {
+      const cachedKeys = Object.keys(cached.stats);
+      const currentKeys = Object.keys(currentStats);
+      if (cachedKeys.length === currentKeys.length) {
+        let match = true;
+        for (const key of currentKeys) {
+          const c = cached.stats[key];
+          const s = currentStats[key];
+          if (!c || c.mtimeMs !== s.mtimeMs || c.size !== s.size) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          let ticket = cached.ticket;
+          if (ticket.meta.links && ticket.meta.links.length > 0) {
+            ticket = {
+              ...ticket,
+              meta: { ...ticket.meta, links: ticket.meta.links.map((l) => ({ ...l })) }
+            };
+            this.enrichTicketLinks(ticket);
+          }
+          return ticket;
+        }
+      }
+    }
+    try {
+      const metaPath = path3.join(ticketDir, "meta.json");
+      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;
+      if (meta.priority) {
+        meta.priority = normalizePriority(meta.priority);
+      }
+      let effectiveLoc = loc;
+      if (loc.isSharedDir) {
+        let found;
+        if (idToDescriptor && codeToDescriptor) {
+          const desc = (meta.projectId !== void 0 ? idToDescriptor.get(meta.projectId) : void 0) || (meta.project ? codeToDescriptor.get(meta.project.toLowerCase()) : void 0);
+          if (desc) {
+            found = locations.find((l) => l.project.code.toLowerCase() === desc.code.toLowerCase());
+          }
+        } else {
+          found = locations.find(
+            (l) => meta.projectId !== void 0 && l.project.id === meta.projectId || meta.project && l.project.code.toLowerCase() === meta.project.toLowerCase()
+          );
+        }
+        if (found) effectiveLoc = found;
+      }
+      meta.project = effectiveLoc.project.code;
+      meta.projectId = effectiveLoc.project.id;
+      if (meta.milestone) {
+        meta.milestone = normalizeDashesAndMojibake(meta.milestone);
+        const mMatch = this.resolveMilestone(meta.milestone, effectiveLoc);
+        if (mMatch?.featureFlag) {
+          meta.inheritedFeatureFlag = mMatch.featureFlag;
+          if (!meta.featureFlag) {
+            meta.featureFlag = mMatch.featureFlag;
+          }
+        }
+      }
+      let detail;
+      const detailPath = path3.join(ticketDir, "detail.md");
+      if (currentStats["detail.md"]) {
+        const raw = fs3.readFileSync(detailPath, "utf-8");
+        detail = this.parseDetailMarkdown(raw);
+      }
+      let planMarkdown;
+      const planPath = path3.join(ticketDir, "implementation_plan.md");
+      if (currentStats["implementation_plan.md"]) {
+        planMarkdown = fs3.readFileSync(planPath, "utf-8");
+      }
+      let comments = [];
+      const commentsPath = path3.join(ticketDir, "comments.json");
+      if (currentStats["comments.json"]) {
+        try {
+          comments = JSON.parse(fs3.readFileSync(commentsPath, "utf-8"));
+        } catch {
+        }
+      }
+      let answers;
+      const answersPath = path3.join(ticketDir, "answers.json");
+      if (currentStats["answers.json"]) {
+        try {
+          answers = JSON.parse(fs3.readFileSync(answersPath, "utf-8"));
+        } catch {
+        }
+      }
+      let inlineComments;
+      const inlinesPath = path3.join(ticketDir, "inline-comments.json");
+      if (currentStats["inline-comments.json"]) {
+        try {
+          inlineComments = JSON.parse(fs3.readFileSync(inlinesPath, "utf-8"));
+        } catch {
+        }
+      }
+      const ticketObj = {
+        meta,
+        detail,
+        planMarkdown,
+        comments,
+        answers,
+        inlineComments,
+        projectDescriptor: effectiveLoc.project
+      };
+      normalizeTicketFields(ticketObj);
+      this.enrichTicketLinks(ticketObj);
+      ticketObj.sha1 = computeTicketHash(ticketObj);
+      ticketObj.lastHash = ticketObj.sha1;
+      this.ticketMemoryCache.set(resolvedTicketDir, {
+        ticket: ticketObj,
+        stats: currentStats
+      });
+      return ticketObj;
+    } catch {
+      return null;
+    }
+  }
   async listTickets(filter) {
     const locations = this.resolveProjectLocations();
     const tickets = [];
     const processedSharedTickets = /* @__PURE__ */ new Set();
+    const codeToDescriptor = /* @__PURE__ */ new Map();
+    const idToDescriptor = /* @__PURE__ */ new Map();
+    for (const l of locations) {
+      codeToDescriptor.set(l.project.code.toLowerCase(), l.project);
+      if (l.project.id !== void 0) {
+        idToDescriptor.set(l.project.id, l.project);
+        idToDescriptor.set(String(l.project.id), l.project);
+      }
+    }
     for (const loc of locations) {
       if (filter?.project && filter.project !== "all") {
-        const pLower = filter.project.toLowerCase();
         if (!isProjectMatch(loc.project.code, filter.project)) {
           continue;
         }
@@ -2099,145 +2361,104 @@ ${formattedList}`
       } catch {
         continue;
       }
+      const activeDirNames = /* @__PURE__ */ new Set();
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const num = parseInt(entry.name, 10);
         if (isNaN(num)) continue;
+        activeDirNames.add(entry.name);
         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;
-          if (meta.priority) {
-            meta.priority = normalizePriority(meta.priority);
-          }
-          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()
-            );
-            if (found) effectiveLoc = found;
-          }
-          meta.project = effectiveLoc.project.code;
-          meta.projectId = effectiveLoc.project.id;
-          let mMatch = null;
-          if (meta.milestone) {
-            meta.milestone = normalizeDashesAndMojibake(meta.milestone);
-            mMatch = this.resolveMilestone(meta.milestone, effectiveLoc);
-            if (mMatch?.featureFlag) {
-              meta.inheritedFeatureFlag = mMatch.featureFlag;
-              if (!meta.featureFlag) {
-                meta.featureFlag = mMatch.featureFlag;
-              }
-            }
-          }
-          if (filter?.project && filter.project !== "all") {
-            const pLower = filter.project.toLowerCase();
-            if (!isProjectMatch(meta.project, filter.project)) {
-              continue;
-            }
-          }
-          if (filter?.milestone) {
-            const mFilter = filter.milestone.trim().toLowerCase();
-            const resolvedFilterMilestone = this.resolveMilestone(filter.milestone, effectiveLoc);
-            const matchesDirect = Boolean(meta.milestone && meta.milestone.toLowerCase() === mFilter);
-            const matchesResolvedTitle = Boolean(
-              resolvedFilterMilestone && meta.milestone && meta.milestone.toLowerCase() === resolvedFilterMilestone.title.toLowerCase()
-            );
-            const matchesResolvedId = Boolean(
-              resolvedFilterMilestone && meta.milestone && String(resolvedFilterMilestone.id).toLowerCase() === meta.milestone.toLowerCase()
-            );
-            const matchesCompound = Boolean(
-              resolvedFilterMilestone && meta.milestone && `${resolvedFilterMilestone.project}:${resolvedFilterMilestone.title}`.toLowerCase() === meta.milestone.toLowerCase()
-            );
-            const matchesResolvedSelf = Boolean(
-              mMatch && (mMatch.title.toLowerCase() === mFilter || String(mMatch.id).toLowerCase() === mFilter || `${mMatch.project}:${mMatch.title}`.toLowerCase() === mFilter || `${mMatch.project}:${mMatch.id}`.toLowerCase() === mFilter)
-            );
-            if (!matchesDirect && !matchesResolvedTitle && !matchesResolvedId && !matchesCompound && !matchesResolvedSelf) {
-              continue;
-            }
-          }
-          if (filter?.status && meta.status !== filter.status) {
+        const ticketObj = this.readTicketFromDir(
+          ticketDir,
+          num,
+          loc,
+          locations,
+          codeToDescriptor,
+          idToDescriptor
+        );
+        if (!ticketObj) continue;
+        const meta = ticketObj.meta;
+        if (filter?.project && filter.project !== "all") {
+          if (!isProjectMatch(meta.project, filter.project)) {
             continue;
           }
-          if (filter?.category && meta.category !== filter.category) {
+        }
+        if (filter?.milestone) {
+          const mFilter = filter.milestone.trim().toLowerCase();
+          const targetLoc = meta.project && locations.find((l) => l.project.code.toLowerCase() === meta.project.toLowerCase()) || loc;
+          const resolvedFilterMilestone = this.resolveMilestone(filter.milestone, targetLoc);
+          const mMatch = meta.milestone ? this.resolveMilestone(meta.milestone, targetLoc) : null;
+          const matchesDirect = Boolean(meta.milestone && meta.milestone.toLowerCase() === mFilter);
+          const matchesResolvedTitle = Boolean(
+            resolvedFilterMilestone && meta.milestone && meta.milestone.toLowerCase() === resolvedFilterMilestone.title.toLowerCase()
+          );
+          const matchesResolvedId = Boolean(
+            resolvedFilterMilestone && meta.milestone && String(resolvedFilterMilestone.id).toLowerCase() === meta.milestone.toLowerCase()
+          );
+          const matchesCompound = Boolean(
+            resolvedFilterMilestone && meta.milestone && `${resolvedFilterMilestone.project}:${resolvedFilterMilestone.title}`.toLowerCase() === meta.milestone.toLowerCase()
+          );
+          const matchesResolvedSelf = Boolean(
+            mMatch && (mMatch.title.toLowerCase() === mFilter || String(mMatch.id).toLowerCase() === mFilter || `${mMatch.project}:${mMatch.title}`.toLowerCase() === mFilter || `${mMatch.project}:${mMatch.id}`.toLowerCase() === mFilter)
+          );
+          if (!matchesDirect && !matchesResolvedTitle && !matchesResolvedId && !matchesCompound && !matchesResolvedSelf) {
             continue;
           }
-          if (filter?.priority !== void 0) {
-            const fPrio = String(filter.priority).trim().toLowerCase();
-            if (fPrio === "none" || fPrio === "null") {
-              if (meta.priority) {
-                continue;
-              }
-            } else {
-              if (!meta.priority || meta.priority.toLowerCase() !== fPrio) {
-                continue;
-              }
+        }
+        if (filter?.status && meta.status !== filter.status) {
+          continue;
+        }
+        if (filter?.category && meta.category !== filter.category) {
+          continue;
+        }
+        if (filter?.priority !== void 0) {
+          const fPrio = String(filter.priority).trim().toLowerCase();
+          if (fPrio === "none" || fPrio === "null") {
+            if (meta.priority) {
+              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) {
+          } else {
+            if (!meta.priority || meta.priority.toLowerCase() !== fPrio) {
               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 {
-            }
+        }
+        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;
           }
-          const ticketObj = {
-            meta,
-            detail,
-            planMarkdown,
-            comments,
-            projectDescriptor: effectiveLoc.project
-          };
-          normalizeTicketFields(ticketObj);
-          this.enrichTicketLinks(ticketObj);
-          ticketObj.sha1 = computeTicketHash(ticketObj);
-          ticketObj.lastHash = ticketObj.sha1;
-          if (filter?.isBlocked !== void 0 && Boolean(ticketObj.isBlocked) !== Boolean(filter.isBlocked)) {
+        }
+        if (filter?.isBlocked !== void 0 && Boolean(ticketObj.isBlocked) !== Boolean(filter.isBlocked)) {
+          continue;
+        }
+        if (filter?.linkedTo) {
+          const target = filter.linkedTo.trim().toLowerCase();
+          const hasLink = ticketObj.meta.links?.some((l) => {
+            const tk = l.targetKey.toLowerCase();
+            const idStr = String(l.targetId);
+            return tk === target || idStr === target;
+          });
+          if (!hasLink) {
             continue;
           }
-          if (filter?.linkedTo) {
-            const target = filter.linkedTo.trim().toLowerCase();
-            const hasLink = ticketObj.meta.links?.some((l) => {
-              const tk = l.targetKey.toLowerCase();
-              const idStr = String(l.targetId);
-              return tk === target || idStr === target;
-            });
-            if (!hasLink) {
-              continue;
-            }
+        }
+        tickets.push(ticketObj);
+      }
+      const locResolvedDir = path3.resolve(loc.ticketsDir);
+      for (const cachedPath of this.ticketMemoryCache.keys()) {
+        if (cachedPath.startsWith(locResolvedDir + path3.sep)) {
+          const folderName = path3.basename(cachedPath);
+          if (!activeDirNames.has(folderName)) {
+            this.ticketMemoryCache.delete(cachedPath);
           }
-          tickets.push(ticketObj);
-        } catch {
         }
       }
     }
@@ -2251,61 +2472,8 @@ ${formattedList}`
   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;
-      if (meta.priority) {
-        meta.priority = normalizePriority(meta.priority);
-      }
-      if (meta.milestone) {
-        meta.milestone = normalizeDashesAndMojibake(meta.milestone);
-        const mMatch = this.resolveMilestone(meta.milestone, locInfo.loc);
-        if (mMatch?.featureFlag) {
-          meta.inheritedFeatureFlag = mMatch.featureFlag;
-          if (!meta.featureFlag) {
-            meta.featureFlag = mMatch.featureFlag;
-          }
-        }
-      }
-      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
-      };
-      normalizeTicketFields(ticket);
-      this.enrichTicketLinks(ticket);
-      ticket.sha1 = computeTicketHash(ticket);
-      ticket.lastHash = ticket.sha1;
-      return ticket;
-    } catch {
-      return null;
-    }
+    const locations = this.resolveProjectLocations();
+    return this.readTicketFromDir(locInfo.ticketDir, locInfo.id, locInfo.loc, locations);
   }
   parseDetailMarkdown(raw) {
     const titleMatch = raw.match(/^#\s*(?:Ticket\s*#?\d+\s*:\s*|\d+\s*:\s*)?([^\n]+)/im);
@@ -2365,6 +2533,63 @@ ${formattedList}`
       raw
     };
   }
+  formatTicketDetailMarkdown(rawDetail, meta, fallbackSummary) {
+    const trimmed = rawDetail.trim();
+    const priorityLine = meta.priority ? `**Priority**: ${meta.priority}  
+` : "";
+    const milestoneLine = meta.milestone ? `**Milestone**: ${meta.milestone}  
+` : "";
+    if (/^#\s+[^\n]+/m.test(trimmed)) {
+      let processed = trimmed.replace(/^#\s+[^\n]+/m, `# Ticket #${meta.id}: ${meta.title}`);
+      if (!/\*\*(?:Type|Category)\*\*:/i.test(processed)) {
+        const metaBlock = `
+**Category**: ${meta.category}  
+${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
+**Estimated Effort**: ${meta.estimatedEffort}  
+`;
+        processed = processed.replace(/^(# Ticket[^\n]+\n)/m, `$1${metaBlock}`);
+      }
+      if (!/(?:##|###)\s*(?:Summary|Rationale)/i.test(processed)) {
+        const summaryBlock = `
+### Summary
+${fallbackSummary || "Summary to be defined."}
+`;
+        processed = processed.replace(/^((?:# Ticket[^\n]+\n)(?:\*\*[^\n]+\n)*)/m, `$1${summaryBlock}`);
+      }
+      return processed.endsWith("\n") ? processed : `${processed}
+`;
+    }
+    const hasSummary = /(?:##|###)\s*(?:Summary|Rationale)/i.test(trimmed);
+    const hasBreakdown = /(?:##|###)\s*Feature Breakdown/i.test(trimmed);
+    let body = "";
+    if (!hasSummary) {
+      body += `### Summary
+${fallbackSummary || "Summary to be defined."}
+
+`;
+    }
+    if (!hasBreakdown && !trimmed.startsWith("#")) {
+      body += `### Feature Breakdown
+${trimmed}
+
+### Technical Details & Architecture
+- Architecture specifications to be documented.
+
+### Open Questions & Decisions
+- None recorded at initialization.
+`;
+    } else {
+      body += `${trimmed}
+`;
+    }
+    return `# Ticket #${meta.id}: ${meta.title}
+**Category**: ${meta.category}  
+${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
+**Estimated Effort**: ${meta.estimatedEffort}  
+
+${body.trim()}
+`;
+  }
   async createTicket(input) {
     const locations = this.resolveProjectLocations();
     if (locations.length === 0) {
@@ -2440,64 +2665,14 @@ ${formattedList}`
       project: targetLoc.project.code
     };
     const rawDetail = cleanDetailRaw?.trim();
-    const priorityLine = meta.priority ? `**Priority**: ${meta.priority}  
-` : "";
-    const milestoneLine = meta.milestone ? `**Milestone**: ${meta.milestone}  
-` : "";
     let detailMd;
     if (rawDetail) {
-      if (/^#\s+[^\n]+/m.test(rawDetail)) {
-        let processed = rawDetail.replace(/^#\s+[^\n]+/m, `# Ticket #${nextId}: ${meta.title}`);
-        if (!/\*\*(?:Type|Category)\*\*:/i.test(processed)) {
-          const metaBlock = `
-**Category**: ${meta.category}  
-${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
-**Estimated Effort**: ${meta.estimatedEffort}  
-`;
-          processed = processed.replace(/^(# Ticket[^\n]+\n)/m, `$1${metaBlock}`);
-        }
-        if (!/(?:##|###)\s*(?:Summary|Rationale)/i.test(processed)) {
-          const summaryBlock = `
-### Summary
-${input.summary || "Summary to be defined."}
-`;
-          processed = processed.replace(/^((?:# Ticket[^\n]+\n)(?:\*\*[^\n]+\n)*)/m, `$1${summaryBlock}`);
-        }
-        detailMd = processed.endsWith("\n") ? processed : `${processed}
-`;
-      } else {
-        const hasSummary = /(?:##|###)\s*(?:Summary|Rationale)/i.test(rawDetail);
-        const hasBreakdown = /(?:##|###)\s*Feature Breakdown/i.test(rawDetail);
-        let body = "";
-        if (!hasSummary) {
-          body += `### Summary
-${input.summary || "Summary to be defined."}
-
-`;
-        }
-        if (!hasBreakdown && !rawDetail.startsWith("#")) {
-          body += `### Feature Breakdown
-${rawDetail}
-
-### Technical Details & Architecture
-- Architecture specifications to be documented.
-
-### Open Questions & Decisions
-- None recorded at initialization.
-`;
-        } else {
-          body += `${rawDetail}
-`;
-        }
-        detailMd = `# Ticket #${nextId}: ${meta.title}
-**Category**: ${meta.category}  
-${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
-**Estimated Effort**: ${meta.estimatedEffort}  
-
-${body.trim()}
-`;
-      }
+      detailMd = this.formatTicketDetailMarkdown(rawDetail, meta, input.summary);
     } else {
+      const priorityLine = meta.priority ? `**Priority**: ${meta.priority}  
+` : "";
+      const milestoneLine = meta.milestone ? `**Milestone**: ${meta.milestone}  
+` : "";
       detailMd = `# Ticket #${nextId}: ${meta.title}
 **Category**: ${meta.category}  
 ${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
@@ -2519,6 +2694,7 @@ ${input.summary || "Summary to be defined."}
     }
     writeSafeFile(path3.join(ticketDir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
     writeSafeFile(path3.join(ticketDir, "detail.md"), detailMd);
+    this.invalidateTicketCache(ticketDir);
     const created = await this.getTicket(`${targetLoc.project.code}-${nextId}`);
     return created;
   }
@@ -2542,7 +2718,8 @@ ${input.summary || "Summary to be defined."}
     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 sanitizedUpdates = { ...updates };
+    const { priority: _p, detail: _d, detailMarkdown: _dm, ...metaFields } = updates;
+    const sanitizedUpdates = { ...metaFields };
     if (sanitizedUpdates.title) sanitizedUpdates.title = normalizeDashesAndMojibake(sanitizedUpdates.title);
     if (sanitizedUpdates.estimatedEffort) sanitizedUpdates.estimatedEffort = normalizeDashesAndMojibake(sanitizedUpdates.estimatedEffort);
     if (sanitizedUpdates.complexity) sanitizedUpdates.complexity = normalizeDashesAndMojibake(sanitizedUpdates.complexity);
@@ -2596,7 +2773,41 @@ ${input.summary || "Summary to be defined."}
       updatedMeta.type = newType;
       updatedMeta.category = newType;
     }
-    if (existing.detail && ("priority" in updates || "milestone" in updates || updates.title || updates.type || updates.category || updates.complexity || updates.estimatedEffort)) {
+    const rawDetailArg = updates.detailMarkdown !== void 0 ? updates.detailMarkdown : updates.detail;
+    if (rawDetailArg !== void 0) {
+      const cleanDetail = normalizeDashesAndMojibake(rawDetailArg);
+      let content = this.formatTicketDetailMarkdown(cleanDetail, updatedMeta, existing.detail?.summary);
+      if (updates.type || updates.category) {
+        content = content.replace(/\*\*(?:Type|Category)\*\*:\s*[^\n]+/i, `**Type**: ${updatedMeta.type}`);
+      }
+      if (updatedMeta.priority) {
+        if (/\*\*Priority\*\*:\s*[^\n]+/i.test(content)) {
+          content = content.replace(/\*\*Priority\*\*:\s*[^\n]+/i, `**Priority**: ${updatedMeta.priority}`);
+        } else if (/\*\*(?:Type|Category)\*\*:\s*[^\n]+/i.test(content)) {
+          content = content.replace(/(\*\*(?:Type|Category)\*\*:\s*[^\n]+)/i, `$1  
+**Priority**: ${updatedMeta.priority}`);
+        }
+      } else if ("priority" in updates) {
+        content = content.replace(/\*\*Priority\*\*:\s*[^\n]+\n?/i, "");
+      }
+      if (updatedMeta.milestone) {
+        if (/\*\*Milestone\*\*:\s*[^\n]+/i.test(content)) {
+          content = content.replace(/\*\*Milestone\*\*:\s*[^\n]+/i, `**Milestone**: ${updatedMeta.milestone}`);
+        } else if (/\*\*(?:Priority|Type|Category)\*\*:\s*[^\n]+/i.test(content)) {
+          content = content.replace(/(\*\*(?:Priority|Type|Category)\*\*:\s*[^\n]+)/i, `$1  
+**Milestone**: ${updatedMeta.milestone}`);
+        }
+      } else if ("milestone" in updates) {
+        content = content.replace(/\*\*Milestone\*\*:\s*[^\n]+\n?/i, "");
+      }
+      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);
+    } else if (existing.detail && ("priority" in updates || "milestone" in updates || 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}`);
@@ -2636,6 +2847,7 @@ ${input.summary || "Summary to be defined."}
       }
       writeSafeFile(path3.join(locInfo.ticketDir, "detail.md"), content);
     }
+    this.invalidateTicketCache(locInfo.ticketDir);
     return await this.getTicket(`${locInfo.loc.project.code}-${locInfo.id}`);
   }
   async getPlan(id) {
@@ -2660,45 +2872,189 @@ ${input.summary || "Summary to be defined."}
     if (!locInfo) {
       throw new Error(`Ticket #${id} could not be located on disk`);
     }
-    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
-    writeSafeFile(planPath, normalizeDashesAndMojibake(planMarkdown));
-    const metaPath = path3.join(locInfo.ticketDir, "meta.json");
-    if (fs3.existsSync(metaPath)) {
+    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
+    writeSafeFile(planPath, normalizeDashesAndMojibake(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 {
+      }
+    }
+    this.invalidateTicketCache(locInfo.ticketDir);
+  }
+  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: normalizeDashesAndMojibake(comment.author || "User"),
+      text: normalizeDashesAndMojibake(comment.text.trim())
+    };
+    comments.push(newComment);
+    writeSafeFile(commentsPath, JSON.stringify(comments, null, 2) + "\n");
+    this.invalidateTicketCache(locInfo.ticketDir);
+    return newComment;
+  }
+  async getAnswers(id) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) return {};
+    const answersPath = path3.join(locInfo.ticketDir, "answers.json");
+    if (!fs3.existsSync(answersPath)) return {};
+    try {
+      return JSON.parse(fs3.readFileSync(answersPath, "utf-8"));
+    } catch {
+      return {};
+    }
+  }
+  async saveAnswer(id, questionIndex, answer) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const answersPath = path3.join(locInfo.ticketDir, "answers.json");
+    let currentAnswers = {};
+    if (fs3.existsSync(answersPath)) {
+      try {
+        currentAnswers = JSON.parse(fs3.readFileSync(answersPath, "utf-8"));
+      } catch {
+      }
+    }
+    currentAnswers[String(questionIndex)] = normalizeDashesAndMojibake(answer);
+    writeSafeFile(answersPath, JSON.stringify(currentAnswers, null, 2) + "\n");
+    this.invalidateTicketCache(locInfo.ticketDir);
+    return currentAnswers;
+  }
+  async saveDetail(id, detailMarkdown, metaUpdates) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    let updatedMeta;
+    if (metaUpdates && Object.keys(metaUpdates).length > 0) {
+      const updatedTicket = await this.updateTicket(id, metaUpdates);
+      updatedMeta = updatedTicket.meta;
+    } else {
+      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 {
+        }
+      }
+    }
+    const detailPath = path3.join(locInfo.ticketDir, "detail.md");
+    writeSafeFile(detailPath, normalizeDashesAndMojibake(detailMarkdown));
+    this.invalidateTicketCache(locInfo.ticketDir);
+    const finalTicket = await this.getTicket(`${locInfo.loc.project.code}-${locInfo.id}`);
+    return {
+      success: true,
+      meta: finalTicket?.meta || updatedMeta,
+      detail: detailMarkdown
+    };
+  }
+  async getInlineComments(id) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) return [];
+    const inlinesPath = path3.join(locInfo.ticketDir, "inline-comments.json");
+    if (!fs3.existsSync(inlinesPath)) return [];
+    try {
+      return JSON.parse(fs3.readFileSync(inlinesPath, "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+  async saveInlineComment(id, selectedText, comment, author) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const inlinesPath = path3.join(locInfo.ticketDir, "inline-comments.json");
+    let currentInlines = [];
+    if (fs3.existsSync(inlinesPath)) {
       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");
+        currentInlines = JSON.parse(fs3.readFileSync(inlinesPath, "utf-8"));
       } catch {
       }
     }
+    const newEntry = {
+      id: `${locInfo.id}-ic-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      selectedText: normalizeDashesAndMojibake(selectedText),
+      comment: normalizeDashesAndMojibake(comment.trim()),
+      author: normalizeDashesAndMojibake(author || "Developer"),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    currentInlines.push(newEntry);
+    writeSafeFile(inlinesPath, JSON.stringify(currentInlines, null, 2) + "\n");
+    this.invalidateTicketCache(locInfo.ticketDir);
+    return currentInlines;
   }
-  async addComment(id, comment) {
-    const ticket = await this.getTicket(id);
-    if (!ticket) {
-      throw new Error(`Ticket #${id} does not exist`);
-    }
+  async saveAttachment(id, filename, buffer) {
     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 attachmentsDir = path3.join(locInfo.ticketDir, "attachments");
+    if (!fs3.existsSync(attachmentsDir)) {
+      fs3.mkdirSync(attachmentsDir, { recursive: true });
     }
-    const newComment = {
-      id: `${locInfo.id}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      author: normalizeDashesAndMojibake(comment.author || "User"),
-      text: normalizeDashesAndMojibake(comment.text.trim())
-    };
-    comments.push(newComment);
-    writeSafeFile(commentsPath, JSON.stringify(comments, null, 2) + "\n");
-    return newComment;
+    const MAX_ATTACHMENT_SIZE_BYTES = 10 * 1024 * 1024;
+    if (buffer.length > MAX_ATTACHMENT_SIZE_BYTES) {
+      throw new Error(`Attachment exceeds maximum allowable size of 10MB (received ${(buffer.length / (1024 * 1024)).toFixed(1)}MB)`);
+    }
+    const MAX_TICKET_ATTACHMENTS = 30;
+    const existingFiles = fs3.readdirSync(attachmentsDir);
+    if (existingFiles.length >= MAX_TICKET_ATTACHMENTS) {
+      throw new Error(`Ticket #${id} has reached the maximum allowed limit of ${MAX_TICKET_ATTACHMENTS} attachments`);
+    }
+    let safeName = path3.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
+    if (!safeName || safeName === "." || safeName === ".." || safeName.replace(/_/g, "") === "") {
+      safeName = `attachment_${Date.now()}`;
+    }
+    let targetFile = path3.join(attachmentsDir, safeName);
+    if (fs3.existsSync(targetFile)) {
+      const ext = path3.extname(safeName);
+      const nameWithoutExt = path3.basename(safeName, ext);
+      safeName = `${nameWithoutExt}_${Date.now()}${ext}`;
+      targetFile = path3.join(attachmentsDir, safeName);
+    }
+    writeSafeFile(targetFile, buffer);
+    this.invalidateTicketCache(locInfo.ticketDir);
+    return { filename: safeName, relativePath: `attachments/${safeName}` };
+  }
+  getAttachmentPath(id, filename) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) return null;
+    const safeName = path3.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
+    if (!safeName || safeName === "." || safeName === "..") return null;
+    const attachmentsDir = path3.resolve(locInfo.ticketDir, "attachments");
+    const target = path3.resolve(attachmentsDir, safeName);
+    if (!target.startsWith(attachmentsDir)) return null;
+    if (fs3.existsSync(target) && fs3.statSync(target).isFile()) {
+      return target;
+    }
+    return null;
   }
   resolveTicketIdentifier(id, defaultProject) {
     const str = String(id).trim();
@@ -2835,6 +3191,7 @@ ${input.summary || "Summary to be defined."}
     sourceMeta.updatedAt = now;
     sourceMeta.revision = (sourceMeta.revision || 1) + 1;
     writeSafeFile(sourceMetaPath, JSON.stringify(sourceMeta, null, 2) + "\n");
+    this.invalidateTicketCache(sourceInfo.ticketDir);
     let updatedTarget;
     const targetMetaPath = path3.join(targetInfo.ticketDir, "meta.json");
     if (fs3.existsSync(targetMetaPath)) {
@@ -2862,6 +3219,7 @@ ${input.summary || "Summary to be defined."}
         targetMeta.updatedAt = now;
         targetMeta.revision = (targetMeta.revision || 1) + 1;
         writeSafeFile(targetMetaPath, JSON.stringify(targetMeta, null, 2) + "\n");
+        this.invalidateTicketCache(targetInfo.ticketDir);
         updatedTarget = await this.getTicket(targetInfo.key) || void 0;
       } catch {
       }
@@ -2890,6 +3248,7 @@ ${input.summary || "Summary to be defined."}
             sourceMeta.updatedAt = now;
             sourceMeta.revision = (sourceMeta.revision || 1) + 1;
             writeSafeFile(sourceMetaPath, JSON.stringify(sourceMeta, null, 2) + "\n");
+            this.invalidateTicketCache(sourceInfo.ticketDir);
           }
         }
       } catch {
@@ -2910,6 +3269,7 @@ ${input.summary || "Summary to be defined."}
               targetMeta.updatedAt = now;
               targetMeta.revision = (targetMeta.revision || 1) + 1;
               writeSafeFile(targetMetaPath, JSON.stringify(targetMeta, null, 2) + "\n");
+              this.invalidateTicketCache(targetInfo.ticketDir);
               updatedTarget = await this.getTicket(targetInfo.key) || void 0;
             }
           }
@@ -3141,6 +3501,81 @@ var SecurityFilter = class {
       target: result.target ? this.redactLinks(result.target) : void 0
     };
   }
+  async getAnswers(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.getAnswers(id);
+  }
+  async saveAnswer(id, questionIndex, answer) {
+    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.saveAnswer(id, questionIndex, answer);
+  }
+  async saveDetail(id, detailMarkdown, metaUpdates) {
+    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.saveDetail(id, detailMarkdown, metaUpdates);
+  }
+  async getInlineComments(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.getInlineComments ? this.target.getInlineComments(id) : [];
+  }
+  async saveInlineComment(id, selectedText, comment, author) {
+    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.saveInlineComment ? this.target.saveInlineComment(id, selectedText, comment, author) : [];
+  }
+  async saveAttachment(id, filename, buffer) {
+    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);
+      }
+    }
+    if (!this.target.saveAttachment) {
+      throw new Error("Attachments are not supported by target storage adapter.");
+    }
+    return this.target.saveAttachment(id, filename, buffer);
+  }
+  getAttachmentPath(id, filename) {
+    if (this.target.findTicketLocation) {
+      const locInfo = this.target.findTicketLocation(id);
+      if (locInfo) {
+        const code = locInfo.loc?.project?.code;
+        if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+          throw new EsedreAuthorizationError(code);
+        }
+      }
+    }
+    return this.target.getAttachmentPath ? this.target.getAttachmentPath(id, filename) : null;
+  }
 };
 
 // src/mcp/server.ts
@@ -3442,6 +3877,8 @@ Status: ${ticket.meta.status}`;
             inDevelopment: { type: "boolean", description: "Active development toggle" },
             featureFlag: { type: "string", description: "Feature flag name" },
             milestone: { type: "string", description: 'Update ticket milestone ("none" to clear)' },
+            detail: { type: "string", description: "Updated specification markdown for ticket detail" },
+            detailMarkdown: { type: "string", description: "Updated specification markdown for ticket detail" },
             lastHash: { type: "string", description: "Optimistic concurrency control: last known sha1 hash of the ticket" }
           },
           required: ["ticketId"]
@@ -3633,6 +4070,8 @@ Status: ${ticket.meta.status}`;
         if (args.inDevelopment !== void 0) updates.isActivePlanning = Boolean(args.inDevelopment);
         if (args.featureFlag) updates.featureFlag = args.featureFlag;
         if (args.milestone !== void 0) updates.milestone = args.milestone;
+        if (args.detail !== void 0) updates.detail = args.detail;
+        if (args.detailMarkdown !== void 0) updates.detailMarkdown = args.detailMarkdown;
         const updated = await this.storage.updateTicket(id, updates, args.lastHash);
         return updated;
       }
@@ -4079,6 +4518,22 @@ async function startDaemon(options = {}) {
   resolveStoreDir(workspaceRoot);
   fs5.mkdirSync(path5.dirname(logFile), { recursive: true });
   fs5.mkdirSync(path5.dirname(stateFile), { recursive: true });
+  const MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
+  try {
+    if (fs5.existsSync(logFile)) {
+      const stats = fs5.statSync(logFile);
+      if (stats.size > MAX_LOG_SIZE_BYTES) {
+        const oldLogFile = `${logFile}.old`;
+        try {
+          if (fs5.existsSync(oldLogFile)) fs5.unlinkSync(oldLogFile);
+          fs5.renameSync(logFile, oldLogFile);
+        } catch {
+          fs5.truncateSync(logFile, 0);
+        }
+      }
+    }
+  } catch {
+  }
   const logFd = fs5.openSync(logFile, "a");
   const isEsedreArgv1 = process.argv[1] && /esedre/i.test(path5.basename(process.argv[1]));
   const cliCandidates = [
@@ -4276,13 +4731,30 @@ function printDaemonLogs(options = {}) {
     console.log(`\x1B[33mNo logs found at: ${logFile}\x1B[0m`);
     return;
   }
-  const content = fs5.readFileSync(logFile, "utf-8");
   const count = options.lines || 40;
+  let content = "";
+  try {
+    const stats = fs5.statSync(logFile);
+    const maxReadBytes = Math.min(stats.size, Math.max(256 * 1024, count * 2048));
+    if (stats.size <= maxReadBytes) {
+      content = fs5.readFileSync(logFile, "utf-8");
+    } else {
+      const fd = fs5.openSync(logFile, "r");
+      const buffer = Buffer.alloc(maxReadBytes);
+      fs5.readSync(fd, buffer, 0, maxReadBytes, stats.size - maxReadBytes);
+      fs5.closeSync(fd);
+      content = buffer.toString("utf-8");
+    }
+  } catch {
+    content = fs5.readFileSync(logFile, "utf-8");
+  }
   const allLines = content.split(/\r?\n/);
-  const tail = allLines.slice(-count).join("\n");
+  const sanitizedLines = allLines.slice(-count).map((line) => {
+    return line.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\r(?!\n)/g, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  });
   console.log(`\x1B[36m--- Esedre Daemon Logs (${logFile}) ---\x1B[0m
 `);
-  console.log(tail);
+  console.log(sanitizedLines.join("\n"));
 }
 
 // src/upgrade.ts
@@ -4933,11 +5405,120 @@ function initHub(targetDir) {
     hubDir: resolved.replace(/\\/g, "/")
   };
 }
+function isWrapperOutdated(esedreCmdContent) {
+  if (!esedreCmdContent || typeof esedreCmdContent !== "string") {
+    return true;
+  }
+  if (/goto\s+:?done\b/i.test(esedreCmdContent)) {
+    return true;
+  }
+  if (/^:done\b/im.test(esedreCmdContent)) {
+    return true;
+  }
+  if (!esedreCmdContent.includes("call :run %*") || !/^:run\b/im.test(esedreCmdContent)) {
+    return true;
+  }
+  return false;
+}
+function findOutdatedWrappers(currentWorkspaceRoot, globalConfig) {
+  const outdated = [];
+  const checkedDirs = /* @__PURE__ */ new Set();
+  const checkDir = (dir, name) => {
+    const resolved = path6.resolve(expandHome(dir));
+    if (checkedDirs.has(resolved.toLowerCase())) return;
+    checkedDirs.add(resolved.toLowerCase());
+    if (!fs6.existsSync(resolved)) return;
+    const cmdPath = path6.join(resolved, ".esedre", "esedre.cmd");
+    if (fs6.existsSync(cmdPath)) {
+      try {
+        const content = fs6.readFileSync(cmdPath, "utf-8");
+        if (isWrapperOutdated(content)) {
+          outdated.push({ name, dir: resolved, wrapperPath: cmdPath });
+        }
+      } catch {
+      }
+    }
+  };
+  if (currentWorkspaceRoot) {
+    checkDir(currentWorkspaceRoot, path6.basename(currentWorkspaceRoot));
+  }
+  if (globalConfig?.projects) {
+    for (const [code, p] of Object.entries(globalConfig.projects)) {
+      checkDir(p, code);
+    }
+  }
+  return outdated;
+}
+async function upgradeAllWorkspaces(options = {}) {
+  const globalCfg = options.globalConfig !== void 0 ? options.globalConfig : readGlobalConfig();
+  const workspaceMap = /* @__PURE__ */ new Map();
+  if (options.currentWorkspaceRoot && fs6.existsSync(options.currentWorkspaceRoot)) {
+    const hasEsedre = fs6.existsSync(path6.join(options.currentWorkspaceRoot, ".esedre")) || fs6.existsSync(path6.join(options.currentWorkspaceRoot, "esedre.json"));
+    if (hasEsedre) {
+      const disc = findEsedreConfig(options.currentWorkspaceRoot, { fallbackToGlobal: true });
+      workspaceMap.set(
+        path6.resolve(options.currentWorkspaceRoot),
+        disc.config?.projectCode || path6.basename(options.currentWorkspaceRoot)
+      );
+    }
+  }
+  if (globalCfg?.projects) {
+    for (const [code, p] of Object.entries(globalCfg.projects)) {
+      const resolved = path6.resolve(expandHome(p));
+      if (fs6.existsSync(resolved)) {
+        if (!workspaceMap.has(resolved)) {
+          workspaceMap.set(resolved, code);
+        }
+      }
+    }
+  }
+  const results = [];
+  for (const [targetDir, name] of workspaceMap.entries()) {
+    try {
+      const targetDiscovered = findEsedreConfig(targetDir, { fallbackToGlobal: true });
+      const projectCode = targetDiscovered.config?.projectCode;
+      const res = configureWorkspace(targetDir, {
+        projectCode,
+        allowedProjects: targetDiscovered.config?.allowedProjects,
+        port: targetDiscovered.config?.port,
+        force: options.force
+      });
+      let totalTickets;
+      if (projectCode) {
+        try {
+          const targetStorage = new SecurityFilter(
+            new FilesystemStorageAdapter(targetDir, targetDiscovered.config),
+            targetDiscovered.config
+          );
+          const snapshot = await generateProjectSnapshot(targetStorage, projectCode, targetDir);
+          totalTickets = snapshot.totalTickets;
+        } catch {
+        }
+      }
+      results.push({
+        dir: targetDir,
+        name,
+        projectCode,
+        upgrade: res,
+        totalTickets
+      });
+    } catch (err) {
+      results.push({
+        dir: targetDir,
+        name,
+        upgrade: {},
+        error: err.message || String(err)
+      });
+    }
+  }
+  const totalUpgraded = results.filter((r) => !r.error && r.upgrade.wrappersPlanted).length;
+  return { workspaces: results, totalUpgraded };
+}
 
 // src/server/gateway.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import http4 from "node:http";
-import path8 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/server/uiServer.ts
@@ -4975,6 +5556,13 @@ function startUiServer(port, webDir) {
     }
     const safePath = path7.normalize(reqPath).replace(/^(\.\.[/\\])+/, "");
     let filePath = path7.join(webDir, safePath);
+    const resolvedFilePath = path7.resolve(filePath);
+    const resolvedWebDir = path7.resolve(webDir);
+    if (!resolvedFilePath.startsWith(resolvedWebDir)) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("Access Denied: Path escapes web root.");
+      return;
+    }
     if (!fs7.existsSync(filePath) || fs7.statSync(filePath).isDirectory()) {
       filePath = path7.join(webDir, "index.html");
     }
@@ -5008,6 +5596,8 @@ function startUiServer(port, webDir) {
 
 // src/server/apiServer.ts
 import http3 from "node:http";
+import fs8 from "node:fs";
+import path8 from "node:path";
 var MAX_JSON_BODY_BYTES = 10 * 1024 * 1024;
 function readJsonBody(req) {
   return new Promise((resolve, reject) => {
@@ -5043,6 +5633,7 @@ function sendJson(res, status, data) {
 }
 var cachedAllData = /* @__PURE__ */ new Map();
 var CACHE_TTL_MS = 5e3;
+var MAX_CACHE_ENTRIES = 30;
 function invalidateApiCache() {
   cachedAllData.clear();
 }
@@ -5142,6 +5733,8 @@ function createApiHandler(storage, workspaceRoot) {
           const detailsMap = {};
           const plansMap = {};
           const commentsMap = {};
+          const answersMap = {};
+          const inlineCommentsMap = {};
           for (const t of tickets) {
             const numKey = String(t.meta.id);
             const code = t.projectDescriptor?.code || t.meta.project || "Profe";
@@ -5167,6 +5760,18 @@ function createApiHandler(storage, workspaceRoot) {
                 plansMap[numKey] = t.planMarkdown;
               }
             }
+            if (t.answers && Object.keys(t.answers).length > 0) {
+              answersMap[prefixedKey] = t.answers;
+              if (!answersMap[numKey] || code.toUpperCase() === "PROF") {
+                answersMap[numKey] = t.answers;
+              }
+            }
+            if (t.inlineComments && t.inlineComments.length > 0) {
+              inlineCommentsMap[prefixedKey] = t.inlineComments;
+              if (!inlineCommentsMap[numKey] || code.toUpperCase() === "PROF") {
+                inlineCommentsMap[numKey] = t.inlineComments;
+              }
+            }
           }
           const projects = await reqStorage.getProjects();
           const responsePayload = {
@@ -5176,11 +5781,15 @@ function createApiHandler(storage, workspaceRoot) {
             details: detailsMap,
             plans: plansMap,
             comments: commentsMap,
-            answers: {},
-            inlineComments: {},
+            answers: answersMap,
+            inlineComments: inlineCommentsMap,
             planHistory: {},
             ticketHistory: {}
           };
+          if (cachedAllData.size >= MAX_CACHE_ENTRIES) {
+            const oldestKey = cachedAllData.keys().next().value;
+            if (oldestKey) cachedAllData.delete(oldestKey);
+          }
           cachedAllData.set(cacheKey, { data: responsePayload, timestamp: now });
           sendJson(res, 200, responsePayload);
           return true;
@@ -5230,11 +5839,88 @@ function createApiHandler(storage, workspaceRoot) {
           return true;
         }
         if (pathname === "/api/planning/inline-comments") {
-          sendJson(res, 200, {});
+          const ticketParam = url.searchParams.get("ticketId") || url.searchParams.get("id");
+          if (ticketParam) {
+            const inlines = reqStorage.getInlineComments ? await reqStorage.getInlineComments(ticketParam) : [];
+            sendJson(res, 200, inlines);
+            return true;
+          }
+          const tickets = await reqStorage.listTickets({});
+          const inlinesMap = {};
+          for (const t of tickets) {
+            if (t.inlineComments && t.inlineComments.length > 0) {
+              inlinesMap[String(t.meta.id)] = t.inlineComments;
+              const code = t.projectDescriptor?.code || t.meta.project;
+              if (code) {
+                inlinesMap[`${code}-${t.meta.id}`] = t.inlineComments;
+              }
+            }
+          }
+          sendJson(res, 200, inlinesMap);
           return true;
         }
         if (pathname === "/api/planning/answers") {
-          sendJson(res, 200, {});
+          const ticketParam = url.searchParams.get("ticketId") || url.searchParams.get("id");
+          if (ticketParam) {
+            const answers = await reqStorage.getAnswers(ticketParam);
+            sendJson(res, 200, answers);
+            return true;
+          }
+          const tickets = await reqStorage.listTickets({});
+          const answersMap = {};
+          for (const t of tickets) {
+            if (t.answers && Object.keys(t.answers).length > 0) {
+              answersMap[String(t.meta.id)] = t.answers;
+              const code = t.projectDescriptor?.code || t.meta.project;
+              if (code) {
+                answersMap[`${code}-${t.meta.id}`] = t.answers;
+              }
+            }
+          }
+          sendJson(res, 200, answersMap);
+          return true;
+        }
+        if (pathname === "/api/planning/attachment") {
+          const ticketId = url.searchParams.get("ticketId") || url.searchParams.get("id");
+          const file = url.searchParams.get("file");
+          if (!ticketId || !file) {
+            sendJson(res, 400, { error: "ticketId and file parameters are required." });
+            return true;
+          }
+          const ticket = await reqStorage.getTicket(ticketId);
+          if (!ticket) {
+            sendJson(res, 404, { error: "Ticket not found." });
+            return true;
+          }
+          const filePath = reqStorage.getAttachmentPath ? reqStorage.getAttachmentPath(ticketId, file) : null;
+          if (!filePath || !fs8.existsSync(filePath)) {
+            sendJson(res, 404, { error: "Attachment not found." });
+            return true;
+          }
+          const stat = fs8.statSync(filePath);
+          if (!stat.isFile()) {
+            sendJson(res, 404, { error: "Attachment not found." });
+            return true;
+          }
+          const ext = path8.extname(filePath).toLowerCase();
+          const mimeTypes = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+            ".svg": "image/svg+xml",
+            ".mp4": "video/mp4",
+            ".webm": "video/webm",
+            ".mov": "video/quicktime"
+          };
+          const contentType = mimeTypes[ext] || "application/octet-stream";
+          res.writeHead(200, {
+            "Content-Type": contentType,
+            "Content-Length": stat.size,
+            "Cache-Control": "public, max-age=86400"
+          });
+          fs8.createReadStream(filePath).pipe(res);
           return true;
         }
         if (pathname === "/api/planning/plan-history") {
@@ -5348,6 +6034,10 @@ function createApiHandler(storage, workspaceRoot) {
         }
         if (pathname === "/api/planning/plans") {
           const { ticketId, planMarkdown, lastHash } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
           invalidateApiCache();
           await reqStorage.savePlan(ticketId, planMarkdown, lastHash);
           sendJson(res, 200, { success: true });
@@ -5355,6 +6045,10 @@ function createApiHandler(storage, workspaceRoot) {
         }
         if (pathname === "/api/planning/comments") {
           const { ticketId, text, author } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
           invalidateApiCache();
           await reqStorage.addComment(ticketId, { author: author || "Developer", text });
           const ticket = await reqStorage.getTicket(ticketId);
@@ -5363,12 +6057,22 @@ function createApiHandler(storage, workspaceRoot) {
         }
         if (pathname === "/api/planning/update-meta") {
           const { ticketId, updates, lastHash } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
+          invalidateApiCache();
           const updated = await reqStorage.updateTicket(ticketId, updates, lastHash);
           sendJson(res, 200, { meta: updated.meta });
           return true;
         }
         if (pathname === "/api/planning/toggle-flag") {
           const { ticketId, flagged } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
+          invalidateApiCache();
           const updated = await reqStorage.updateTicket(ticketId, {
             featureFlag: flagged ? "chat_enhanced" : ""
           });
@@ -5377,10 +6081,56 @@ function createApiHandler(storage, workspaceRoot) {
         }
         if (pathname === "/api/planning/details") {
           const { ticketId, detailMarkdown, metaUpdates } = body;
-          if (metaUpdates) {
-            await reqStorage.updateTicket(ticketId, metaUpdates);
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
+          invalidateApiCache();
+          const result = await reqStorage.saveDetail(ticketId, detailMarkdown || "", metaUpdates);
+          sendJson(res, 200, result);
+          return true;
+        }
+        if (pathname === "/api/planning/answers") {
+          const { ticketId, questionIndex, answer } = body;
+          if (ticketId === void 0 || questionIndex === void 0 || answer === void 0) {
+            sendJson(res, 400, { error: "ticketId, questionIndex, and answer are required." });
+            return true;
+          }
+          invalidateApiCache();
+          const updated = await reqStorage.saveAnswer(ticketId, Number(questionIndex), String(answer));
+          sendJson(res, 200, updated);
+          return true;
+        }
+        if (pathname === "/api/planning/save-inline-comment" || pathname === "/api/planning/inline-comments") {
+          const { ticketId, selectedText, comment, author } = body;
+          if (!ticketId || !selectedText || !comment) {
+            sendJson(res, 400, { error: "ticketId, selectedText, and comment are required." });
+            return true;
           }
-          sendJson(res, 200, { success: true, detail: detailMarkdown });
+          invalidateApiCache();
+          const inlineComments = reqStorage.saveInlineComment ? await reqStorage.saveInlineComment(ticketId, selectedText, comment, author) : [];
+          sendJson(res, 200, { inlineComments });
+          return true;
+        }
+        if (pathname === "/api/planning/upload-attachment") {
+          const { ticketId, filename, base64Data } = body;
+          if (!ticketId || !filename || !base64Data) {
+            sendJson(res, 400, { error: "ticketId, filename, and base64Data are required." });
+            return true;
+          }
+          const base64Content = base64Data.replace(/^data:[^;]+;base64,/, "");
+          const buffer = Buffer.from(base64Content, "base64");
+          if (!reqStorage.saveAttachment) {
+            sendJson(res, 500, { error: "Attachments are not supported by the storage engine." });
+            return true;
+          }
+          invalidateApiCache();
+          const saved = await reqStorage.saveAttachment(ticketId, filename, buffer);
+          sendJson(res, 200, {
+            success: true,
+            filename: saved.filename,
+            url: `/api/planning/attachment?ticketId=${encodeURIComponent(ticketId)}&file=${encodeURIComponent(saved.filename)}`
+          });
           return true;
         }
         if (pathname === "/api/planning/milestones") {
@@ -5461,35 +6211,35 @@ function startApiServer(port, storage, workspaceRoot) {
 
 // src/server/gateway.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path8.dirname(__filename2);
+var __dirname2 = path9.dirname(__filename2);
 function resolveWebDir(explicitWebDir, workspaceRoot) {
-  if (explicitWebDir && fs8.existsSync(path8.join(explicitWebDir, "index.html"))) {
+  if (explicitWebDir && fs9.existsSync(path9.join(explicitWebDir, "index.html"))) {
     return explicitWebDir;
   }
   const candidates = [
     // 1. Packaged layout right next to executable (e.g. tools/web)
-    path8.resolve(__dirname2, "web"),
+    path9.resolve(__dirname2, "web"),
     // 2. From workspace root: <workspaceRoot>/dist/web
-    workspaceRoot ? path8.resolve(workspaceRoot, "dist", "web") : "",
+    workspaceRoot ? path9.resolve(workspaceRoot, "dist", "web") : "",
     // 3. In-repo legacy subfolder: <workspaceRoot>/esedre/dist/web
-    workspaceRoot ? path8.resolve(workspaceRoot, "esedre", "dist", "web") : "",
+    workspaceRoot ? path9.resolve(workspaceRoot, "esedre", "dist", "web") : "",
     // 4. Sibling standalone repository from workspace root: <workspaceRoot>/../esedre/dist/web
-    workspaceRoot ? path8.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
+    workspaceRoot ? path9.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
     // 5. Packaged layout inside dist/web
-    path8.resolve(__dirname2, "dist", "web"),
+    path9.resolve(__dirname2, "dist", "web"),
     // 6. Sibling standalone repository from __dirname: <__dirname>/../../esedre/dist/web
-    path8.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
+    path9.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
     // 7. Source tree layout: esedre/src/server/ -> esedre/dist/web
-    path8.resolve(__dirname2, "..", "..", "dist", "web"),
+    path9.resolve(__dirname2, "..", "..", "dist", "web"),
     // 8. Legacy layout from __dirname
-    path8.resolve(__dirname2, "..", "esedre", "dist", "web")
+    path9.resolve(__dirname2, "..", "esedre", "dist", "web")
   ].filter(Boolean);
   for (const candidate of candidates) {
-    if (fs8.existsSync(path8.join(candidate, "index.html"))) {
+    if (fs9.existsSync(path9.join(candidate, "index.html"))) {
       return candidate;
     }
   }
-  return candidates[0] || path8.resolve(__dirname2, "web");
+  return candidates[0] || path9.resolve(__dirname2, "web");
 }
 function proxyRequest(req, res, targetPort, rewritePath) {
   const targetPath = rewritePath ? rewritePath(req.url || "/") : req.url || "/";
@@ -5609,7 +6359,7 @@ ${colors.bold}ROADMAP COMMANDS (Pair Programming & LLM Agents):${colors.reset}
   ${colors.bold}create${colors.reset}      --title "..." [-p|--project <code>] [-t|--type <type>] [-P|--priority <prio>] [--complexity <c>] [--effort "<e>"] [--summary "<s>"] [--detail "<md>"] [--file <path>] [--json]
                Mint a new roadmap ticket with sequential numeric ID.
 
-  ${colors.bold}update${colors.reset}      <id> [-s|--status <status>] [-t|--type <type>] [-P|--priority <prio>] [--title "..."] [--complexity <c>] [--effort "<e>"] [--in-dev] [--flag <name>] [--last-hash <sha1>] [--force] [--json]
+  ${colors.bold}update${colors.reset}      <id> [-s|--status <status>] [-t|--type <type>] [-P|--priority <prio>] [--title "..."] [--complexity <c>] [--effort "<e>"] [--detail "<md>"] [--file <path>] [--in-dev] [--flag <name>] [--last-hash <sha1>] [--force] [--json]
                Mutate ticket status, type, priority, title, complexity, effort, active state, or feature flag with OCC protection.
 
   ${colors.bold}comment${colors.reset}     <id> ["<text>"] [--text "..."] [--author "..."] [--json]
@@ -5661,8 +6411,9 @@ ${colors.bold}DEVELOPER ADMINISTRATION (Human Setup & Configuration):${colors.re
                \u2022 remove <target>  Unlink a project or data hub
                \u2022 set <key> <val>  Update a central configuration setting
 
-  ${colors.bold}upgrade${colors.reset}     [<path>] [--force|-f] [--json]
+  ${colors.bold}upgrade${colors.reset}     [<path>] [--all|-a] [--force|-f] [--json]
                Upgrade workspace configuration schema, wrappers, and agent skills. Refreshes snapshot.
+               Pass --all (-a) to upgrade all registered projects in central ~/.esedre/config.json.
                Pass --force to overwrite customized skills with the latest official template.
 
   ${colors.bold}projects${colors.reset}    [--json]
@@ -5675,6 +6426,7 @@ ${colors.bold}DEVELOPER ADMINISTRATION (Human Setup & Configuration):${colors.re
                Safely rename a project code on disk, updating hub folders, manifests, ticket references, and workspace configs.
 
 ${colors.bold}OPTIONS:${colors.reset}
+  -a, --all            Apply operation across all registered projects in central configuration.
   -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').
@@ -5686,8 +6438,8 @@ ${colors.bold}OPTIONS:${colors.reset}
   --to <targetId>      Target ticket ID for link/unlink commands.
   --blocked            Filter tickets that are blocked by uncompleted tickets.
   --linked-to <key>    Filter tickets that are linked to a specific ticket.
-  --detail "<md>"      Specification markdown for ticket detail during create.
-  --file <path>        Path to markdown file for detail (create) or implementation plan (plan).
+  --detail "<md>"      Specification markdown for ticket detail during create or update.
+  --file <path>        Path to markdown file for detail (create, update) or implementation plan (plan).
   --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.
@@ -5752,6 +6504,7 @@ function parseArgs(rawArgs) {
   if (flags["q"] && !flags["search"]) flags["search"] = flags["q"];
   if (flags["r"] && !flags["relation"]) flags["relation"] = flags["r"];
   if (flags["f"] && !flags["foreground"]) flags["foreground"] = flags["f"];
+  if (flags["a"] && !flags["all"]) flags["all"] = flags["a"];
   return { command, positionals, flags };
 }
 function printDuplicateProjectWarnings(storage, isJson) {
@@ -5759,7 +6512,7 @@ function printDuplicateProjectWarnings(storage, isJson) {
   const warnings = storage.getDuplicateProjectWarnings ? storage.getDuplicateProjectWarnings() : [];
   for (const warn of warnings) {
     console.error(
-      `${colors.yellow}\u26A0\uFE0F  Warning: Duplicate project code '${warn.code}' detected across multiple data hubs (${path9.basename(warn.firstHub)} and ${path9.basename(warn.duplicateHub)}). Duplicate project codes across hubs are not supported; only '${path9.basename(warn.firstHub)}' is active.${colors.reset}`
+      `${colors.yellow}\u26A0\uFE0F  Warning: Duplicate project code '${warn.code}' detected across multiple data hubs (${path10.basename(warn.firstHub)} and ${path10.basename(warn.duplicateHub)}). Duplicate project codes across hubs are not supported; only '${path10.basename(warn.firstHub)}' is active.${colors.reset}`
     );
   }
 }
@@ -5802,7 +6555,7 @@ async function main() {
     switch (command) {
       case "init": {
         const rawTarget = positionals[0];
-        const targetDir = rawTarget ? path9.resolve(rawTarget) : discovered.workspaceRoot;
+        const targetDir = rawTarget ? path10.resolve(rawTarget) : discovered.workspaceRoot;
         const rawHubFlag = flags["hub"];
         const hubArg = typeof rawHubFlag === "string" ? rawHubFlag : void 0;
         const isHubRequested = Boolean(rawHubFlag);
@@ -5881,7 +6634,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
           console.error(`${colors.red}Error: ${nameVal.error}${colors.reset}`);
           process.exit(1);
         }
-        const isTargetHub = fs9.existsSync(path9.join(targetDir, "projects.json")) || fs9.existsSync(path9.join(targetDir, "projects")) && !fs9.existsSync(path9.join(targetDir, ".esedre", "esedre.json"));
+        const isTargetHub = fs10.existsSync(path10.join(targetDir, "projects.json")) || fs10.existsSync(path10.join(targetDir, "projects")) && !fs10.existsSync(path10.join(targetDir, ".esedre", "esedre.json"));
         const isWorkspaceless = isHubRequested || isTargetHub || Boolean(discovered.config?.projectCode) && !rawTarget && discovered.config?.projectCode?.toLowerCase() !== projectCode.toLowerCase();
         let projectNewlyRegistered = false;
         let registeredProj;
@@ -5952,7 +6705,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
         const viteConfigPath = findViteConfig(targetDir);
         if (viteConfigPath && setupProxy === void 0 && !isJson) {
           try {
-            const rawContent = fs9.readFileSync(viteConfigPath, "utf-8");
+            const rawContent = fs10.readFileSync(viteConfigPath, "utf-8");
             const alreadyConfigured = rawContent.includes("'/esedre'") || rawContent.includes('"/esedre"');
             if (!alreadyConfigured) {
               if (isYes) {
@@ -5962,7 +6715,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
                 const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
                 try {
                   const answer = await rl.question(
-                    `${colors.cyan}?${colors.reset} Detected ${colors.bold}${path9.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] `
+                    `${colors.cyan}?${colors.reset} Detected ${colors.bold}${path10.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";
@@ -5978,10 +6731,13 @@ ${colors.bold}Next Steps:${colors.reset}`);
         let hubRelPath = void 0;
         if (rawHub) {
           const singleHub = Array.isArray(rawHub) ? rawHub[0] : rawHub;
-          const resolvedHub = path9.resolve(expandHome(singleHub));
-          if (fs9.existsSync(resolvedHub)) {
-            const rel = path9.relative(targetDir, resolvedHub).replace(/\\/g, "/");
-            hubRelPath = rel.startsWith(".") ? rel : "./" + rel;
+          const resolvedHub = path10.resolve(expandHome(singleHub));
+          if (fs10.existsSync(resolvedHub)) {
+            const rel = path10.relative(targetDir, resolvedHub).replace(/\\/g, "/");
+            const isSubdir = !rel.startsWith("..") && !path10.isAbsolute(rel);
+            if (isSubdir || Boolean(flags["data-dir"])) {
+              hubRelPath = rel.startsWith(".") ? rel : "./" + rel;
+            }
           }
         }
         const res = initWorkspace(targetDir, {
@@ -6152,7 +6908,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
         }
         console.log(`
 ${colors.bold}${colors.cyan}Esedre Central Configuration${colors.reset}`);
-        console.log(`  \u2022 Config File:  ${configPath} ${fs9.existsSync(configPath) ? colors.green + "(active)" + colors.reset : colors.dim + "(default)" + colors.reset}`);
+        console.log(`  \u2022 Config File:  ${configPath} ${fs10.existsSync(configPath) ? colors.green + "(active)" + colors.reset : colors.dim + "(default)" + colors.reset}`);
         console.log(`  \u2022 Default Port: ${globalCfg.port || DEFAULT_ESEDRE_PORT}`);
         console.log(`
 ${colors.bold}Data Hubs (dataDir):${colors.reset}`);
@@ -6184,9 +6940,46 @@ ${colors.bold}Commands:${colors.reset}`);
         return;
       }
       case "upgrade": {
-        const targetDir = positionals[0] ? path9.resolve(positionals[0]) : discovered.workspaceRoot;
-        const targetDiscovered = targetDir === discovered.workspaceRoot ? discovered : findEsedreConfig(targetDir, { fallbackToGlobal: true });
+        const isAll = Boolean(flags["all"] || flags["a"]);
         const isForce = Boolean(flags["force"] || flags["f"]);
+        if (isAll) {
+          const globalCfg = readGlobalConfig();
+          const allRes = await upgradeAllWorkspaces({
+            currentWorkspaceRoot: discovered.workspaceRoot,
+            globalConfig: globalCfg,
+            force: isForce
+          });
+          if (isJson) {
+            console.log(JSON.stringify(allRes, null, 2));
+            return;
+          }
+          if (allRes.workspaces.length === 0) {
+            console.log(`${colors.yellow}No registered workspaces found to upgrade.${colors.reset}`);
+            return;
+          }
+          console.log(`
+${colors.bold}${colors.green}\u2714 Esedre multi-workspace upgrade completed across ${allRes.workspaces.length} workspace(s):${colors.reset}`);
+          for (const w of allRes.workspaces) {
+            if (w.error) {
+              console.log(`  \u2022 ${colors.red}\u2717 ${w.name} (${w.dir}): ${w.error}${colors.reset}`);
+            } else {
+              const snapStr = w.totalTickets !== void 0 ? ` (${w.totalTickets} tickets projected)` : "";
+              console.log(`  \u2022 ${colors.bold}${w.name}${colors.reset} (${w.dir}):`);
+              console.log(`    - Wrappers updated in .esedre/`);
+              if (w.totalTickets !== void 0) {
+                console.log(`    - Refreshed .esedre/snapshot.json${snapStr}`);
+              }
+              if (w.upgrade.skillConfigured) {
+                console.log(`    - Updated .agents/skills/esedre/SKILL.md`);
+              } else if (w.upgrade.skillStatus === "CUSTOMIZED") {
+                console.log(`    - Preserved customized .agents/skills/esedre/SKILL.md`);
+              }
+            }
+          }
+          return;
+        }
+        const targetDir = positionals[0] ? path10.resolve(positionals[0]) : discovered.workspaceRoot;
+        const targetDiscovered = targetDir === discovered.workspaceRoot ? discovered : findEsedreConfig(targetDir, { fallbackToGlobal: true });
         const res = configureWorkspace(targetDir, {
           projectCode: targetDiscovered.config?.projectCode,
           allowedProjects: targetDiscovered.config?.allowedProjects,
@@ -6293,8 +7086,10 @@ ${colors.dim}Shutting down Esedre cluster...${colors.reset}`);
         const flagPort = flags["port"] ? parseInt(String(flags["port"]), 10) : void 0;
         const port = resolvePorts(discovered.config, { port: flagPort }).gateway;
         const status = await getDaemonStatus({ port, workspaceRoot: discovered.workspaceRoot });
+        const globalCfg = readGlobalConfig() || discovered.config;
+        const outdatedWrappers = findOutdatedWrappers(discovered.workspaceRoot, globalCfg);
         if (isJson) {
-          console.log(JSON.stringify(status, null, 2));
+          console.log(JSON.stringify({ ...status, outdatedWrappers }, null, 2));
         } else {
           if (status.running) {
             console.log(`${colors.bold}${colors.green}\u25CF Esedre daemon is RUNNING${colors.reset}`);
@@ -6312,10 +7107,14 @@ ${colors.yellow}\u26A0\uFE0F  Warning: Daemon is running v${status.version}, but
             }
           } else {
             console.log(`${colors.yellow}\u25CB Esedre daemon is STOPPED (port ${status.port})${colors.reset}`);
-            if (status.logFile && fs9.existsSync(status.logFile)) {
+            if (status.logFile && fs10.existsSync(status.logFile)) {
               console.log(`  \u2022 Recent Logs: ${status.logFile}`);
             }
           }
+          if (outdatedWrappers.length > 0) {
+            console.log(`
+${colors.yellow}Notice: ${outdatedWrappers.length} workspace(s) have legacy CMD wrappers (${outdatedWrappers.map((o) => o.name).join(", ")}). Run 'ese upgrade --all' to update.${colors.reset}`);
+          }
         }
         return;
       }
@@ -6513,11 +7312,11 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         if (setPlan || filePath) {
           let content = setPlan;
           if (filePath) {
-            if (!fs9.existsSync(filePath)) {
+            if (!fs10.existsSync(filePath)) {
               console.error(`${colors.red}Error: Plan file "${filePath}" not found.${colors.reset}`);
               process.exit(1);
             }
-            content = fs9.readFileSync(filePath, "utf-8");
+            content = fs10.readFileSync(filePath, "utf-8");
           }
           await storage.savePlan(id, content, lastHash);
           if (isJson) {
@@ -6589,8 +7388,8 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         const milestone = flags["milestone"] || flags["m"] || void 0;
         let detailMarkdown = detailArg;
         if (fileArg) {
-          const filePath = path9.resolve(fileArg);
-          if (!fs9.existsSync(filePath)) {
+          const filePath = path10.resolve(fileArg);
+          if (!fs10.existsSync(filePath)) {
             if (isJson) {
               console.error(JSON.stringify({ error: `Detail file "${fileArg}" not found` }));
             } else {
@@ -6598,7 +7397,7 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
             }
             process.exit(1);
           }
-          detailMarkdown = fs9.readFileSync(filePath, "utf-8");
+          detailMarkdown = fs10.readFileSync(filePath, "utf-8");
         }
         const created = await storage.createTicket({
           title,
@@ -6664,6 +7463,22 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         if (inDev !== void 0) updates.isActivePlanning = inDev;
         if (flag) updates.featureFlag = flag;
         if (rawMilestone !== void 0) updates.milestone = rawMilestone;
+        const detailArg = flags["detail"];
+        const fileArg = flags["file"];
+        let detailMarkdown = detailArg ? normalizeDashesAndMojibake(detailArg) : void 0;
+        if (fileArg) {
+          const filePath = path10.resolve(fileArg);
+          if (!fs10.existsSync(filePath)) {
+            if (isJson) {
+              console.error(JSON.stringify({ error: `Detail file "${fileArg}" not found` }));
+            } else {
+              console.error(`${colors.red}Error: Detail file "${fileArg}" not found.${colors.reset}`);
+            }
+            process.exit(1);
+          }
+          detailMarkdown = normalizeDashesAndMojibake(fs10.readFileSync(filePath, "utf-8"));
+        }
+        if (detailMarkdown !== void 0) updates.detailMarkdown = detailMarkdown;
         const updated = await storage.updateTicket(lookupKey, updates, lastHash);
         if (isJson) {
           console.log(JSON.stringify(updated, null, 2));