esedre 1.0.1 → 1.2.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 fs11 from "node:fs";
+import path11 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.2.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) {
@@ -2672,6 +2884,7 @@ ${input.summary || "Summary to be defined."}
       } catch {
       }
     }
+    this.invalidateTicketCache(locInfo.ticketDir);
   }
   async addComment(id, comment) {
     const ticket = await this.getTicket(id);
@@ -2698,8 +2911,151 @@ ${input.summary || "Summary to be defined."}
     };
     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 {
+        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 saveAttachment(id, filename, buffer) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const attachmentsDir = path3.join(locInfo.ticketDir, "attachments");
+    if (!fs3.existsSync(attachmentsDir)) {
+      fs3.mkdirSync(attachmentsDir, { recursive: true });
+    }
+    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();
     if (!/^([a-zA-Z0-9]{1,8})[-_:](\d+)$/i.test(str) && defaultProject && defaultProject !== "all") {
@@ -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,9 +3501,86 @@ 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
+import fs4 from "node:fs";
+import path4 from "node:path";
 import readline from "node:readline";
 var EsedreMcpServer = class {
   storage;
@@ -3365,7 +3802,8 @@ Status: ${ticket.meta.status}`;
             milestone: { type: "string", description: "Filter tickets by milestone name or ID" },
             search: { type: "string", description: "Search keywords in title or ID" },
             isBlocked: { type: "boolean", description: "Filter tickets blocked by uncompleted tickets" },
-            linkedTo: { type: "string", description: "Filter tickets linked to a specific ticket ID or key" }
+            linkedTo: { type: "string", description: "Filter tickets linked to a specific ticket ID or key" },
+            includePlan: { type: "boolean", description: "When true, includes implementation plan markdown (planMarkdown) for each ticket" }
           }
         }
       },
@@ -3442,6 +3880,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"]
@@ -3455,9 +3895,10 @@ Status: ${ticket.meta.status}`;
           properties: {
             ticketId: { type: ["integer", "string"], description: "Numeric ticket ID or compound key" },
             text: { type: "string", description: "Comment message" },
+            file: { type: "string", description: "Path to local file containing comment message markdown" },
             author: { type: "string", description: "Author name (e.g. Antigravity, Developer)" }
           },
-          required: ["ticketId", "text"]
+          required: ["ticketId"]
         }
       },
       {
@@ -3554,6 +3995,7 @@ Status: ${ticket.meta.status}`;
     switch (canonical) {
       case "list_tickets": {
         const type = args.type || args.category;
+        const includePlan = Boolean(args.includePlan);
         const tickets = await this.storage.listTickets({
           project: args.project,
           status: args.status,
@@ -3565,23 +4007,39 @@ Status: ${ticket.meta.status}`;
           isBlocked: args.isBlocked !== void 0 ? Boolean(args.isBlocked) : void 0,
           linkedTo: args.linkedTo
         });
-        return 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,
-          priority: t.meta.priority,
-          complexity: t.meta.complexity,
-          effort: t.meta.estimatedEffort,
-          milestone: t.meta.milestone,
-          featureFlag: t.meta.featureFlag,
-          inheritedFeatureFlag: t.meta.inheritedFeatureFlag,
-          project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
-          sha1: t.sha1 || t.meta.sha1,
-          isBlocked: t.isBlocked,
-          links: t.links
-        }));
+        const results = await Promise.all(
+          tickets.map(async (t) => {
+            let planMarkdown = t.planMarkdown;
+            if (includePlan && planMarkdown === void 0) {
+              const lookupKey = t.projectDescriptor?.code ? `${t.projectDescriptor.code}-${t.meta.id}` : t.meta.id;
+              planMarkdown = await this.storage.getPlan(lookupKey) ?? null;
+            }
+            const hasPlan = Boolean(
+              t.planMarkdown && t.planMarkdown.trim().length > 0 || planMarkdown && planMarkdown.trim().length > 0
+            );
+            return {
+              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,
+              priority: t.meta.priority,
+              complexity: t.meta.complexity,
+              effort: t.meta.estimatedEffort,
+              milestone: t.meta.milestone,
+              featureFlag: t.meta.featureFlag,
+              inheritedFeatureFlag: t.meta.inheritedFeatureFlag,
+              project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
+              summary: t.detail?.summary,
+              hasPlan,
+              ...includePlan ? { planMarkdown: planMarkdown || null } : {},
+              sha1: t.sha1 || t.meta.sha1,
+              isBlocked: t.isBlocked,
+              links: t.links
+            };
+          })
+        );
+        return results;
       }
       case "get_ticket": {
         const id = this.parseTicketId(args.ticketId);
@@ -3633,13 +4091,33 @@ 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;
       }
       case "add_comment": {
         const id = this.parseTicketId(args.ticketId);
+        let text = args.text;
+        if (!text && args.file) {
+          const resolvedPath = path4.resolve(process.cwd(), args.file);
+          if (!fs4.existsSync(resolvedPath)) {
+            throw new Error(`File not found: ${args.file}`);
+          }
+          if (!fs4.statSync(resolvedPath).isFile()) {
+            throw new Error(`Path is not a file: ${args.file}`);
+          }
+          const fileContent = fs4.readFileSync(resolvedPath, "utf-8");
+          if (!fileContent.trim()) {
+            throw new Error(`Comment file is empty: ${args.file}`);
+          }
+          text = fileContent;
+        }
+        if (!text || !text.trim()) {
+          throw new Error("Comment text or file is required");
+        }
         const comment = await this.storage.addComment(id, {
-          text: args.text,
+          text,
           author: args.author || "Agent"
         });
         return comment;
@@ -3708,19 +4186,19 @@ Status: ${ticket.meta.status}`;
 };
 
 // src/utils/manifestDetector.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 function sanitizeCode(input) {
   const clean = input.replace(/[^a-zA-Z0-9]/g, "");
   return clean.slice(0, MAX_PROJECT_CODE_LENGTH) || "APP";
 }
 function detectProjectManifest(targetDir) {
-  const dirBase = path4.basename(targetDir);
+  const dirBase = path5.basename(targetDir);
   for (const settingsFile of ["settings.gradle.kts", "settings.gradle"]) {
-    const fullPath = path4.join(targetDir, settingsFile);
-    if (fs4.existsSync(fullPath)) {
+    const fullPath = path5.join(targetDir, settingsFile);
+    if (fs5.existsSync(fullPath)) {
       try {
-        const content = fs4.readFileSync(fullPath, "utf-8");
+        const content = fs5.readFileSync(fullPath, "utf-8");
         const match = content.match(/rootProject\.name\s*=\s*["']([^"']+)["']/);
         if (match && match[1].trim()) {
           const rawName = match[1].trim();
@@ -3736,15 +4214,15 @@ function detectProjectManifest(targetDir) {
     }
   }
   for (const buildFile of [
-    path4.join("app", "build.gradle.kts"),
+    path5.join("app", "build.gradle.kts"),
     "build.gradle.kts",
-    path4.join("app", "build.gradle"),
+    path5.join("app", "build.gradle"),
     "build.gradle"
   ]) {
-    const fullPath = path4.join(targetDir, buildFile);
-    if (fs4.existsSync(fullPath)) {
+    const fullPath = path5.join(targetDir, buildFile);
+    if (fs5.existsSync(fullPath)) {
       try {
-        const content = fs4.readFileSync(fullPath, "utf-8");
+        const content = fs5.readFileSync(fullPath, "utf-8");
         const match = content.match(/(?:namespace|applicationId)\s*=\s*["']([^"']+)["']/);
         if (match && match[1].trim()) {
           const ns = match[1].trim();
@@ -3761,10 +4239,10 @@ function detectProjectManifest(targetDir) {
       }
     }
   }
-  const pomPath = path4.join(targetDir, "pom.xml");
-  if (fs4.existsSync(pomPath)) {
+  const pomPath = path5.join(targetDir, "pom.xml");
+  if (fs5.existsSync(pomPath)) {
     try {
-      const content = fs4.readFileSync(pomPath, "utf-8");
+      const content = fs5.readFileSync(pomPath, "utf-8");
       const stripped = content.replace(/<!--[\s\S]*?-->/g, "").replace(/<parent>[\s\S]*?<\/parent>/g, "");
       const nameMatch = stripped.match(/<name>\s*([^<]+)\s*<\/name>/);
       const artifactMatch = stripped.match(/<artifactId>\s*([^<]+)\s*<\/artifactId>/) || content.match(/<artifactId>\s*([^<]+)\s*<\/artifactId>/);
@@ -3783,10 +4261,10 @@ function detectProjectManifest(targetDir) {
     } catch {
     }
   }
-  const pkgPath = path4.join(targetDir, "package.json");
-  if (fs4.existsSync(pkgPath)) {
+  const pkgPath = path5.join(targetDir, "package.json");
+  if (fs5.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         const baseName = pkg.name.replace(/^@[\w-]+\//, "");
         return {
@@ -3799,10 +4277,10 @@ function detectProjectManifest(targetDir) {
     } catch {
     }
   }
-  const cargoPath = path4.join(targetDir, "Cargo.toml");
-  if (fs4.existsSync(cargoPath)) {
+  const cargoPath = path5.join(targetDir, "Cargo.toml");
+  if (fs5.existsSync(cargoPath)) {
     try {
-      const content = fs4.readFileSync(cargoPath, "utf-8");
+      const content = fs5.readFileSync(cargoPath, "utf-8");
       const match = content.match(/\[package\][\s\S]*?name\s*=\s*["']([^"']+)["']/);
       if (match && match[1].trim()) {
         const rawName = match[1].trim();
@@ -3816,10 +4294,10 @@ function detectProjectManifest(targetDir) {
     } catch {
     }
   }
-  const pyprojectPath = path4.join(targetDir, "pyproject.toml");
-  if (fs4.existsSync(pyprojectPath)) {
+  const pyprojectPath = path5.join(targetDir, "pyproject.toml");
+  if (fs5.existsSync(pyprojectPath)) {
     try {
-      const content = fs4.readFileSync(pyprojectPath, "utf-8");
+      const content = fs5.readFileSync(pyprojectPath, "utf-8");
       const match = content.match(/name\s*=\s*["']([^"']+)["']/);
       if (match && match[1].trim()) {
         const rawName = match[1].trim();
@@ -3833,10 +4311,10 @@ function detectProjectManifest(targetDir) {
     } catch {
     }
   }
-  const setupCfgPath = path4.join(targetDir, "setup.cfg");
-  if (fs4.existsSync(setupCfgPath)) {
+  const setupCfgPath = path5.join(targetDir, "setup.cfg");
+  if (fs5.existsSync(setupCfgPath)) {
     try {
-      const content = fs4.readFileSync(setupCfgPath, "utf-8");
+      const content = fs5.readFileSync(setupCfgPath, "utf-8");
       const match = content.match(/^name\s*=\s*([^\r\n]+)/m);
       if (match && match[1].trim()) {
         const rawName = match[1].trim();
@@ -3850,10 +4328,10 @@ function detectProjectManifest(targetDir) {
     } catch {
     }
   }
-  const setupPyPath = path4.join(targetDir, "setup.py");
-  if (fs4.existsSync(setupPyPath)) {
+  const setupPyPath = path5.join(targetDir, "setup.py");
+  if (fs5.existsSync(setupPyPath)) {
     try {
-      const content = fs4.readFileSync(setupPyPath, "utf-8");
+      const content = fs5.readFileSync(setupPyPath, "utf-8");
       const match = content.match(/name\s*=\s*["']([^"']+)["']/);
       if (match && match[1].trim()) {
         const rawName = match[1].trim();
@@ -3867,10 +4345,10 @@ function detectProjectManifest(targetDir) {
     } catch {
     }
   }
-  const goModPath = path4.join(targetDir, "go.mod");
-  if (fs4.existsSync(goModPath)) {
+  const goModPath = path5.join(targetDir, "go.mod");
+  if (fs5.existsSync(goModPath)) {
     try {
-      const content = fs4.readFileSync(goModPath, "utf-8");
+      const content = fs5.readFileSync(goModPath, "utf-8");
       const match = content.match(/^module\s+([^\r\n\s]+)/m);
       if (match && match[1].trim()) {
         const modPath = match[1].trim();
@@ -3894,48 +4372,48 @@ function detectProjectManifest(targetDir) {
 
 // src/upgrade.ts
 import crypto2 from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 
 // src/server/daemon.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import os3 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 = path5.dirname(__filename);
+var __dirname = path6.dirname(__filename);
 function getGlobalEsedreDir() {
   if (process.env.ESEDRE_GLOBAL_DIR) {
     return process.env.ESEDRE_GLOBAL_DIR;
   }
-  return path5.join(os3.homedir(), ".esedre");
+  return path6.join(os3.homedir(), ".esedre");
 }
 function ensureGlobalEsedreStore() {
   const globalDir = getGlobalEsedreDir();
-  const runDir = path5.join(globalDir, "run");
-  const logsDir = path5.join(globalDir, "logs");
+  const runDir = path6.join(globalDir, "run");
+  const logsDir = path6.join(globalDir, "logs");
   try {
-    fs5.mkdirSync(runDir, { recursive: true });
-    fs5.mkdirSync(logsDir, { recursive: true });
+    fs6.mkdirSync(runDir, { recursive: true });
+    fs6.mkdirSync(logsDir, { recursive: true });
     try {
-      const runEntries = fs5.readdirSync(runDir);
+      const runEntries = fs6.readdirSync(runDir);
       for (const entry of runEntries) {
         if (entry.startsWith(".probe-")) {
-          fs5.unlinkSync(path5.join(runDir, entry));
+          fs6.unlinkSync(path6.join(runDir, entry));
         }
       }
     } catch {
     }
-    const testProbe = path5.join(runDir, `.probe-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`);
+    const testProbe = path6.join(runDir, `.probe-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`);
     try {
-      fs5.writeFileSync(testProbe, "ok", "utf-8");
+      fs6.writeFileSync(testProbe, "ok", "utf-8");
       return { ok: true, path: globalDir };
     } finally {
-      if (fs5.existsSync(testProbe)) {
+      if (fs6.existsSync(testProbe)) {
         try {
-          fs5.unlinkSync(testProbe);
+          fs6.unlinkSync(testProbe);
         } catch {
         }
       }
@@ -3950,10 +4428,10 @@ function resolveStoreDir(workspaceRoot) {
     return globalStore.path;
   }
   if (workspaceRoot) {
-    const localStore = path5.join(workspaceRoot, ".esedre");
+    const localStore = path6.join(workspaceRoot, ".esedre");
     try {
-      fs5.mkdirSync(path5.join(localStore, "run"), { recursive: true });
-      fs5.mkdirSync(path5.join(localStore, "logs"), { recursive: true });
+      fs6.mkdirSync(path6.join(localStore, "run"), { recursive: true });
+      fs6.mkdirSync(path6.join(localStore, "logs"), { recursive: true });
       return localStore;
     } catch {
     }
@@ -3962,32 +4440,32 @@ function resolveStoreDir(workspaceRoot) {
 }
 function getDaemonStateFile(port, workspaceRoot) {
   const store = resolveStoreDir(workspaceRoot);
-  return path5.join(store, "run", `daemon-${port}.json`);
+  return path6.join(store, "run", `daemon-${port}.json`);
 }
 function getDaemonLogFile(port, workspaceRoot) {
   const store = resolveStoreDir(workspaceRoot);
-  return path5.join(store, "logs", `daemon-${port}.log`);
+  return path6.join(store, "logs", `daemon-${port}.log`);
 }
 function getDaemonState(port, workspaceRoot) {
   const stateFile = getDaemonStateFile(port, workspaceRoot);
-  if (!fs5.existsSync(stateFile)) {
+  if (!fs6.existsSync(stateFile)) {
     return null;
   }
   try {
-    const raw = fs5.readFileSync(stateFile, "utf-8").trim();
+    const raw = fs6.readFileSync(stateFile, "utf-8").trim();
     if (!raw) {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
       return null;
     }
     const state = JSON.parse(raw);
     if (!state || typeof state.pid !== "number" || typeof state.port !== "number") {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
       return null;
     }
     return state;
   } catch {
     try {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
     } catch {
     }
     return null;
@@ -4058,7 +4536,7 @@ async function startDaemon(options = {}) {
       }
     }
     try {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
     } catch {
     }
   }
@@ -4077,24 +4555,40 @@ async function startDaemon(options = {}) {
     };
   }
   resolveStoreDir(workspaceRoot);
-  fs5.mkdirSync(path5.dirname(logFile), { recursive: true });
-  fs5.mkdirSync(path5.dirname(stateFile), { recursive: true });
-  const logFd = fs5.openSync(logFile, "a");
-  const isEsedreArgv1 = process.argv[1] && /esedre/i.test(path5.basename(process.argv[1]));
+  fs6.mkdirSync(path6.dirname(logFile), { recursive: true });
+  fs6.mkdirSync(path6.dirname(stateFile), { recursive: true });
+  const MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
+  try {
+    if (fs6.existsSync(logFile)) {
+      const stats = fs6.statSync(logFile);
+      if (stats.size > MAX_LOG_SIZE_BYTES) {
+        const oldLogFile = `${logFile}.old`;
+        try {
+          if (fs6.existsSync(oldLogFile)) fs6.unlinkSync(oldLogFile);
+          fs6.renameSync(logFile, oldLogFile);
+        } catch {
+          fs6.truncateSync(logFile, 0);
+        }
+      }
+    }
+  } catch {
+  }
+  const logFd = fs6.openSync(logFile, "a");
+  const isEsedreArgv1 = process.argv[1] && /esedre/i.test(path6.basename(process.argv[1]));
   const cliCandidates = [
-    isEsedreArgv1 ? path5.resolve(process.argv[1]) : void 0,
-    path5.resolve(workspaceRoot, "dist", "esedre.mjs"),
-    path5.resolve(workspaceRoot, "../esedre/dist", "esedre.mjs"),
-    path5.resolve(__dirname, "esedre.mjs"),
-    path5.resolve(__dirname, "..", "dist", "esedre.mjs"),
-    path5.resolve(__dirname, "..", "..", "dist", "esedre.mjs"),
-    path5.resolve(__dirname, "..", "..", "bin", "esedre.js"),
-    path5.resolve(__dirname, "..", "..", "bin", "esedre.ts"),
-    path5.resolve(__dirname, "..", "esedre.mjs"),
-    path5.resolve(__dirname, "../../../esedre/dist", "esedre.mjs")
+    isEsedreArgv1 ? path6.resolve(process.argv[1]) : void 0,
+    path6.resolve(workspaceRoot, "dist", "esedre.mjs"),
+    path6.resolve(workspaceRoot, "../esedre/dist", "esedre.mjs"),
+    path6.resolve(__dirname, "esedre.mjs"),
+    path6.resolve(__dirname, "..", "dist", "esedre.mjs"),
+    path6.resolve(__dirname, "..", "..", "dist", "esedre.mjs"),
+    path6.resolve(__dirname, "..", "..", "bin", "esedre.js"),
+    path6.resolve(__dirname, "..", "..", "bin", "esedre.ts"),
+    path6.resolve(__dirname, "..", "esedre.mjs"),
+    path6.resolve(__dirname, "../../../esedre/dist", "esedre.mjs")
   ].filter(Boolean);
-  const cliPath = cliCandidates.find((c) => fs5.existsSync(c) && (c.endsWith(".mjs") || c.endsWith(".js") || c.endsWith(".ts"))) || cliCandidates[0];
-  if (!fs5.existsSync(cliPath)) {
+  const cliPath = cliCandidates.find((c) => fs6.existsSync(c) && (c.endsWith(".mjs") || c.endsWith(".js") || c.endsWith(".ts"))) || cliCandidates[0];
+  if (!fs6.existsSync(cliPath)) {
     throw new Error(`Could not locate Esedre executable. Searched candidates: ${cliCandidates.join(", ")}`);
   }
   const child = spawn(process.execPath, [cliPath, "start", "--foreground", "--port", String(port)], {
@@ -4106,7 +4600,7 @@ async function startDaemon(options = {}) {
   });
   child.unref();
   try {
-    fs5.closeSync(logFd);
+    fs6.closeSync(logFd);
   } catch {
   }
   const pid = child.pid;
@@ -4147,13 +4641,13 @@ async function startDaemon(options = {}) {
     logFile
   };
   const tmpState = `${stateFile}.tmp.${Date.now()}`;
-  fs5.writeFileSync(tmpState, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  fs6.writeFileSync(tmpState, JSON.stringify(state, null, 2) + "\n", "utf-8");
   try {
-    fs5.renameSync(tmpState, stateFile);
+    fs6.renameSync(tmpState, stateFile);
   } catch {
-    fs5.writeFileSync(stateFile, JSON.stringify(state, null, 2) + "\n", "utf-8");
+    fs6.writeFileSync(stateFile, JSON.stringify(state, null, 2) + "\n", "utf-8");
     try {
-      fs5.unlinkSync(tmpState);
+      fs6.unlinkSync(tmpState);
     } catch {
     }
   }
@@ -4216,8 +4710,8 @@ async function stopDaemon(options = {}) {
     }
   }
   try {
-    if (fs5.existsSync(stateFile)) {
-      fs5.unlinkSync(stateFile);
+    if (fs6.existsSync(stateFile)) {
+      fs6.unlinkSync(stateFile);
     }
   } catch {
   }
@@ -4254,7 +4748,7 @@ async function getDaemonStatus(options = {}) {
   }
   if (state && !isProcessAlive(state.pid)) {
     try {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
     } catch {
     }
   }
@@ -4272,17 +4766,34 @@ function printDaemonLogs(options = {}) {
   const port = resolvePorts(void 0, { port: options.port }).gateway;
   const workspaceRoot = options.workspaceRoot || process.cwd();
   const logFile = getDaemonLogFile(port, workspaceRoot);
-  if (!fs5.existsSync(logFile)) {
+  if (!fs6.existsSync(logFile)) {
     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 = fs6.statSync(logFile);
+    const maxReadBytes = Math.min(stats.size, Math.max(256 * 1024, count * 2048));
+    if (stats.size <= maxReadBytes) {
+      content = fs6.readFileSync(logFile, "utf-8");
+    } else {
+      const fd = fs6.openSync(logFile, "r");
+      const buffer = Buffer.alloc(maxReadBytes);
+      fs6.readSync(fd, buffer, 0, maxReadBytes, stats.size - maxReadBytes);
+      fs6.closeSync(fd);
+      content = buffer.toString("utf-8");
+    }
+  } catch {
+    content = fs6.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
@@ -4489,13 +5000,13 @@ When Esedre MCP is active in your agent session (\`.agents/mcp_config.json\`), u
 
 | Tool | Purpose | Key Arguments |
 |---|---|---|
-| \`esedre_list_tickets\` | List roadmap tickets with filters | \`project\` (e.g. \`Profe\`, \`Esedre\`, \`Alce\`), \`status\`, \`type\`, \`search\` |
+| \`esedre_list_tickets\` | List roadmap tickets with filters | \`project\` (e.g. \`Profe\`, \`Esedre\`, \`Alce\`), \`status\`, \`type\`, \`priority\`, \`milestone\`, \`isBlocked\`, \`linkedTo\`, \`search\`, \`includePlan\` |
 | \`esedre_get_ticket\` | Full specification, summary, comments, revision & sha1 | \`ticketId\` (numeric e.g. \`96\` or compound e.g. \`Profe-96\`) |
 | \`esedre_get_plan\` | Active implementation plan markdown | \`ticketId\` (numeric or compound) |
 | \`esedre_save_plan\` | Save implementation plan markdown with OCC | \`ticketId\`, \`planMarkdown\`, \`lastHash\` |
 | \`esedre_create_ticket\` | Mint a new ticket with auto sequential ID | \`title\` (max 48 chars), \`type\`, \`project\`, \`effort\`, \`summary\`, \`detail\` |
 | \`esedre_update_ticket\` | Update ticket attributes with OCC | \`ticketId\`, \`status\`, \`type\`, \`title\`, \`complexity\`, \`effort\`, \`inDevelopment\`, \`featureFlag\`, \`lastHash\` |
-| \`esedre_add_comment\` | Append developer or agent comment | \`ticketId\`, \`text\`, \`author\` |
+| \`esedre_add_comment\` | Append developer or agent comment | \`ticketId\`, \`text\`, \`file\`, \`author\` |
 
 ## 2. Core CLI Commands (Fallback via \`run_command\`)
 
@@ -4533,6 +5044,7 @@ Both \`esedre\` and \`ese\` work interchangeably:
 ### Append Comments or Notes
 \`\`\`bash
 .esedre/ese comment <ticketId> "Verified implementation." --author "Agent"
+.esedre/ese comment <ticketId> --file <commentFilePath> --author "Agent"
 .esedre/ese comment <ticketId> --text "Verified implementation." --author "Agent"
 \`\`\`
 
@@ -4588,8 +5100,8 @@ If the host application declares any or all of the 12 core design tokens on \`:r
   - The URL hash is preserved across hard page refreshes (F5) without falling back to \`#/chat\` or other views.
 `;
 function plantWrappers(targetDir) {
-  const esedreDir = path6.join(targetDir, ".esedre");
-  fs6.mkdirSync(esedreDir, { recursive: true });
+  const esedreDir = path7.join(targetDir, ".esedre");
+  fs7.mkdirSync(esedreDir, { recursive: true });
   const wrappers = [
     { name: "esedre.cmd", content: WRAPPER_CMD, exec: false },
     { name: "esedre.ps1", content: WRAPPER_PS1, exec: false },
@@ -4599,24 +5111,24 @@ function plantWrappers(targetDir) {
     { name: "ese", content: ESE_WRAPPER_BASH, exec: true }
   ];
   for (const w of wrappers) {
-    const fullPath = path6.join(esedreDir, w.name);
-    fs6.writeFileSync(fullPath, w.content, "utf-8");
+    const fullPath = path7.join(esedreDir, w.name);
+    fs7.writeFileSync(fullPath, w.content, "utf-8");
     if (w.exec) {
       try {
-        fs6.chmodSync(fullPath, 493);
+        fs7.chmodSync(fullPath, 493);
       } catch {
       }
     }
   }
 }
 function setupMcpConfig(targetDir) {
-  const agentsDir = path6.join(targetDir, ".agents");
-  fs6.mkdirSync(agentsDir, { recursive: true });
-  const mcpConfigPath = path6.join(agentsDir, "mcp_config.json");
+  const agentsDir = path7.join(targetDir, ".agents");
+  fs7.mkdirSync(agentsDir, { recursive: true });
+  const mcpConfigPath = path7.join(agentsDir, "mcp_config.json");
   let configObj = { mcpServers: {} };
-  if (fs6.existsSync(mcpConfigPath)) {
+  if (fs7.existsSync(mcpConfigPath)) {
     try {
-      configObj = JSON.parse(fs6.readFileSync(mcpConfigPath, "utf-8"));
+      configObj = JSON.parse(fs7.readFileSync(mcpConfigPath, "utf-8"));
       if (!configObj.mcpServers) configObj.mcpServers = {};
     } catch {
     }
@@ -4633,28 +5145,28 @@ function setupMcpConfig(targetDir) {
     };
   }
   try {
-    fs6.writeFileSync(mcpConfigPath, JSON.stringify(configObj, null, 2) + "\n", "utf-8");
+    fs7.writeFileSync(mcpConfigPath, JSON.stringify(configObj, null, 2) + "\n", "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function setupSkill(targetDir, options = {}) {
-  const skillDir = path6.join(targetDir, ".agents", "skills", "esedre");
-  fs6.mkdirSync(skillDir, { recursive: true });
-  const skillFile = path6.join(skillDir, "SKILL.md");
-  if (!fs6.existsSync(skillFile)) {
-    fs6.writeFileSync(skillFile, ESEDRE_SKILL_TEMPLATE, "utf-8");
+  const skillDir = path7.join(targetDir, ".agents", "skills", "esedre");
+  fs7.mkdirSync(skillDir, { recursive: true });
+  const skillFile = path7.join(skillDir, "SKILL.md");
+  if (!fs7.existsSync(skillFile)) {
+    fs7.writeFileSync(skillFile, ESEDRE_SKILL_TEMPLATE, "utf-8");
     return { status: "MISSING", updated: true };
   }
-  const currentContent = fs6.readFileSync(skillFile, "utf-8");
+  const currentContent = fs7.readFileSync(skillFile, "utf-8");
   const status = classifyContent(currentContent, ESEDRE_SKILL_TEMPLATE, HISTORIC_SKILL_HASHES);
   if (status === "LATEST" && !options.force) {
     return { status, updated: false };
   }
   const hasBannedOrDeprecatedTerms = currentContent.includes("companion agent") || currentContent.includes("companion LLM") || currentContent.includes("tools/esedre.mjs");
   if (options.force || status === "HISTORIC_DEFAULT" || status === "MISSING" || hasBannedOrDeprecatedTerms) {
-    fs6.writeFileSync(skillFile, ESEDRE_SKILL_TEMPLATE, "utf-8");
+    fs7.writeFileSync(skillFile, ESEDRE_SKILL_TEMPLATE, "utf-8");
     return { status: "LATEST", updated: true };
   }
   return { status, updated: false };
@@ -4668,8 +5180,8 @@ var VITE_CONFIG_FILES = [
 ];
 function findViteConfig(targetDir) {
   for (const name of VITE_CONFIG_FILES) {
-    const fullPath = path6.join(targetDir, name);
-    if (fs6.existsSync(fullPath)) {
+    const fullPath = path7.join(targetDir, name);
+    if (fs7.existsSync(fullPath)) {
       return fullPath;
     }
   }
@@ -4733,10 +5245,10 @@ function configureViteProxy(targetDir, port = DEFAULT_ESEDRE_PORT, setupProxy) {
       recommendedProxySnippet: snippet
     };
   }
-  const relativeName = path6.basename(configPath);
+  const relativeName = path7.basename(configPath);
   let content = "";
   try {
-    content = fs6.readFileSync(configPath, "utf-8");
+    content = fs7.readFileSync(configPath, "utf-8");
   } catch {
     return {
       status: "MANUAL_REQUIRED",
@@ -4767,7 +5279,7 @@ function configureViteProxy(targetDir, port = DEFAULT_ESEDRE_PORT, setupProxy) {
     };
   }
   try {
-    fs6.writeFileSync(configPath, injected, "utf-8");
+    fs7.writeFileSync(configPath, injected, "utf-8");
     return {
       status: "CONFIGURED",
       configFile: relativeName,
@@ -4782,15 +5294,15 @@ function configureViteProxy(targetDir, port = DEFAULT_ESEDRE_PORT, setupProxy) {
   }
 }
 function configureWorkspace(targetDir, options = {}) {
-  const esedreDir = path6.join(targetDir, ".esedre");
-  if (!fs6.existsSync(esedreDir)) {
-    fs6.mkdirSync(esedreDir, { recursive: true });
+  const esedreDir = path7.join(targetDir, ".esedre");
+  if (!fs7.existsSync(esedreDir)) {
+    fs7.mkdirSync(esedreDir, { recursive: true });
   }
-  const esedreJsonPath = path6.join(esedreDir, "esedre.json");
+  const esedreJsonPath = path7.join(esedreDir, "esedre.json");
   let existingRaw = null;
-  if (fs6.existsSync(esedreJsonPath)) {
+  if (fs7.existsSync(esedreJsonPath)) {
     try {
-      existingRaw = JSON.parse(fs6.readFileSync(esedreJsonPath, "utf-8"));
+      existingRaw = JSON.parse(fs7.readFileSync(esedreJsonPath, "utf-8"));
     } catch {
     }
   }
@@ -4826,16 +5338,16 @@ function configureWorkspace(targetDir, options = {}) {
       port: options.port || void 0
     };
   }
-  fs6.writeFileSync(esedreJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs7.writeFileSync(esedreJsonPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   let projectRegistered = false;
   if (projectCode) {
-    const hasExistingTicketsDir = fs6.existsSync(path6.join(targetDir, "tickets")) || fs6.existsSync(path6.join(targetDir, "src", "data", "planning", "tickets"));
-    const ticketsDir = path6.join(esedreDir, "tickets");
-    if (!hasExistingTicketsDir && !fs6.existsSync(ticketsDir)) {
-      fs6.mkdirSync(ticketsDir, { recursive: true });
+    const hasExistingTicketsDir = fs7.existsSync(path7.join(targetDir, "tickets")) || fs7.existsSync(path7.join(targetDir, "src", "data", "planning", "tickets"));
+    const ticketsDir = path7.join(esedreDir, "tickets");
+    if (!hasExistingTicketsDir && !fs7.existsSync(ticketsDir)) {
+      fs7.mkdirSync(ticketsDir, { recursive: true });
     }
-    const inRepoPJson = path6.join(esedreDir, "project.json");
-    if (!fs6.existsSync(inRepoPJson)) {
+    const inRepoPJson = path7.join(esedreDir, "project.json");
+    if (!fs7.existsSync(inRepoPJson)) {
       const projDesc = {
         id: 1,
         code: projectCode.toUpperCase(),
@@ -4847,14 +5359,14 @@ function configureWorkspace(targetDir, options = {}) {
           border: "border-cyan-500/40"
         }
       };
-      fs6.writeFileSync(inRepoPJson, JSON.stringify(projDesc, null, 2) + "\n", "utf-8");
+      fs7.writeFileSync(inRepoPJson, JSON.stringify(projDesc, null, 2) + "\n", "utf-8");
       projectRegistered = true;
     } else if (projectName) {
       try {
-        const existing = JSON.parse(fs6.readFileSync(inRepoPJson, "utf-8"));
+        const existing = JSON.parse(fs7.readFileSync(inRepoPJson, "utf-8"));
         if (existing.name !== projectName) {
           existing.name = projectName;
-          fs6.writeFileSync(inRepoPJson, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+          fs7.writeFileSync(inRepoPJson, JSON.stringify(existing, null, 2) + "\n", "utf-8");
         }
       } catch {
       }
@@ -4904,26 +5416,26 @@ var ESEDRE_HUB_AGENTS_TEMPLATE = `# Agent Guidelines: esedre-data
 When inspecting or managing tickets for any project (such as \`Profe\`, \`Esedre\`, or \`Alce\`), navigate to that project's workspace and utilize its local \`.esedre/snapshot.json\`, Esedre MCP tools, or \`.esedre/ese\` CLI wrapper.
 `;
 function initHub(targetDir) {
-  const resolved = path6.resolve(targetDir);
-  if (!fs6.existsSync(resolved)) {
-    fs6.mkdirSync(resolved, { recursive: true });
+  const resolved = path7.resolve(targetDir);
+  if (!fs7.existsSync(resolved)) {
+    fs7.mkdirSync(resolved, { recursive: true });
   }
-  const projectsDir = path6.join(resolved, "projects");
+  const projectsDir = path7.join(resolved, "projects");
   let projectsDirCreated = false;
-  if (!fs6.existsSync(projectsDir)) {
-    fs6.mkdirSync(projectsDir, { recursive: true });
+  if (!fs7.existsSync(projectsDir)) {
+    fs7.mkdirSync(projectsDir, { recursive: true });
     projectsDirCreated = true;
   }
-  const projectsJsonPath = path6.join(resolved, "projects.json");
+  const projectsJsonPath = path7.join(resolved, "projects.json");
   let projectsJsonCreated = false;
-  if (!fs6.existsSync(projectsJsonPath)) {
-    fs6.writeFileSync(projectsJsonPath, "[]\n", "utf-8");
+  if (!fs7.existsSync(projectsJsonPath)) {
+    fs7.writeFileSync(projectsJsonPath, "[]\n", "utf-8");
     projectsJsonCreated = true;
   }
-  const agentsMdPath = path6.join(resolved, "AGENTS.md");
+  const agentsMdPath = path7.join(resolved, "AGENTS.md");
   let agentsMdCreated = false;
-  if (!fs6.existsSync(agentsMdPath)) {
-    fs6.writeFileSync(agentsMdPath, ESEDRE_HUB_AGENTS_TEMPLATE, "utf-8");
+  if (!fs7.existsSync(agentsMdPath)) {
+    fs7.writeFileSync(agentsMdPath, ESEDRE_HUB_AGENTS_TEMPLATE, "utf-8");
     agentsMdCreated = true;
   }
   return {
@@ -4933,17 +5445,126 @@ 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 = path7.resolve(expandHome(dir));
+    if (checkedDirs.has(resolved.toLowerCase())) return;
+    checkedDirs.add(resolved.toLowerCase());
+    if (!fs7.existsSync(resolved)) return;
+    const cmdPath = path7.join(resolved, ".esedre", "esedre.cmd");
+    if (fs7.existsSync(cmdPath)) {
+      try {
+        const content = fs7.readFileSync(cmdPath, "utf-8");
+        if (isWrapperOutdated(content)) {
+          outdated.push({ name, dir: resolved, wrapperPath: cmdPath });
+        }
+      } catch {
+      }
+    }
+  };
+  if (currentWorkspaceRoot) {
+    checkDir(currentWorkspaceRoot, path7.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 && fs7.existsSync(options.currentWorkspaceRoot)) {
+    const hasEsedre = fs7.existsSync(path7.join(options.currentWorkspaceRoot, ".esedre")) || fs7.existsSync(path7.join(options.currentWorkspaceRoot, "esedre.json"));
+    if (hasEsedre) {
+      const disc = findEsedreConfig(options.currentWorkspaceRoot, { fallbackToGlobal: true });
+      workspaceMap.set(
+        path7.resolve(options.currentWorkspaceRoot),
+        disc.config?.projectCode || path7.basename(options.currentWorkspaceRoot)
+      );
+    }
+  }
+  if (globalCfg?.projects) {
+    for (const [code, p] of Object.entries(globalCfg.projects)) {
+      const resolved = path7.resolve(expandHome(p));
+      if (fs7.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 fs10 from "node:fs";
 import http4 from "node:http";
-import path8 from "node:path";
+import path10 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/server/uiServer.ts
 import http2 from "node:http";
-import fs7 from "node:fs";
-import path7 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -4973,20 +5594,27 @@ function startUiServer(port, webDir) {
     if (!reqPath || reqPath === "/") {
       reqPath = "/index.html";
     }
-    const safePath = path7.normalize(reqPath).replace(/^(\.\.[/\\])+/, "");
-    let filePath = path7.join(webDir, safePath);
-    if (!fs7.existsSync(filePath) || fs7.statSync(filePath).isDirectory()) {
-      filePath = path7.join(webDir, "index.html");
+    const safePath = path8.normalize(reqPath).replace(/^(\.\.[/\\])+/, "");
+    let filePath = path8.join(webDir, safePath);
+    const resolvedFilePath = path8.resolve(filePath);
+    const resolvedWebDir = path8.resolve(webDir);
+    if (!resolvedFilePath.startsWith(resolvedWebDir)) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("Access Denied: Path escapes web root.");
+      return;
+    }
+    if (!fs8.existsSync(filePath) || fs8.statSync(filePath).isDirectory()) {
+      filePath = path8.join(webDir, "index.html");
     }
-    if (!fs7.existsSync(filePath)) {
+    if (!fs8.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 = path7.extname(filePath).toLowerCase();
+    const ext = path8.extname(filePath).toLowerCase();
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     try {
-      const content = fs7.readFileSync(filePath);
+      const content = fs8.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch (err) {
@@ -5008,6 +5636,8 @@ function startUiServer(port, webDir) {
 
 // src/server/apiServer.ts
 import http3 from "node:http";
+import fs9 from "node:fs";
+import path9 from "node:path";
 var MAX_JSON_BODY_BYTES = 10 * 1024 * 1024;
 function readJsonBody(req) {
   return new Promise((resolve, reject) => {
@@ -5043,6 +5673,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 +5773,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 +5800,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 +5821,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 +5879,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 || !fs9.existsSync(filePath)) {
+            sendJson(res, 404, { error: "Attachment not found." });
+            return true;
+          }
+          const stat = fs9.statSync(filePath);
+          if (!stat.isFile()) {
+            sendJson(res, 404, { error: "Attachment not found." });
+            return true;
+          }
+          const ext = path9.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"
+          });
+          fs9.createReadStream(filePath).pipe(res);
           return true;
         }
         if (pathname === "/api/planning/plan-history") {
@@ -5348,6 +6074,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 +6085,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 +6097,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 +6121,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;
+          }
+          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;
           }
-          sendJson(res, 200, { success: true, detail: detailMarkdown });
+          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 +6251,35 @@ function startApiServer(port, storage, workspaceRoot) {
 
 // src/server/gateway.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path8.dirname(__filename2);
+var __dirname2 = path10.dirname(__filename2);
 function resolveWebDir(explicitWebDir, workspaceRoot) {
-  if (explicitWebDir && fs8.existsSync(path8.join(explicitWebDir, "index.html"))) {
+  if (explicitWebDir && fs10.existsSync(path10.join(explicitWebDir, "index.html"))) {
     return explicitWebDir;
   }
   const candidates = [
     // 1. Packaged layout right next to executable (e.g. tools/web)
-    path8.resolve(__dirname2, "web"),
+    path10.resolve(__dirname2, "web"),
     // 2. From workspace root: <workspaceRoot>/dist/web
-    workspaceRoot ? path8.resolve(workspaceRoot, "dist", "web") : "",
+    workspaceRoot ? path10.resolve(workspaceRoot, "dist", "web") : "",
     // 3. In-repo legacy subfolder: <workspaceRoot>/esedre/dist/web
-    workspaceRoot ? path8.resolve(workspaceRoot, "esedre", "dist", "web") : "",
+    workspaceRoot ? path10.resolve(workspaceRoot, "esedre", "dist", "web") : "",
     // 4. Sibling standalone repository from workspace root: <workspaceRoot>/../esedre/dist/web
-    workspaceRoot ? path8.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
+    workspaceRoot ? path10.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
     // 5. Packaged layout inside dist/web
-    path8.resolve(__dirname2, "dist", "web"),
+    path10.resolve(__dirname2, "dist", "web"),
     // 6. Sibling standalone repository from __dirname: <__dirname>/../../esedre/dist/web
-    path8.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
+    path10.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
     // 7. Source tree layout: esedre/src/server/ -> esedre/dist/web
-    path8.resolve(__dirname2, "..", "..", "dist", "web"),
+    path10.resolve(__dirname2, "..", "..", "dist", "web"),
     // 8. Legacy layout from __dirname
-    path8.resolve(__dirname2, "..", "esedre", "dist", "web")
+    path10.resolve(__dirname2, "..", "esedre", "dist", "web")
   ].filter(Boolean);
   for (const candidate of candidates) {
-    if (fs8.existsSync(path8.join(candidate, "index.html"))) {
+    if (fs10.existsSync(path10.join(candidate, "index.html"))) {
       return candidate;
     }
   }
-  return candidates[0] || path8.resolve(__dirname2, "web");
+  return candidates[0] || path10.resolve(__dirname2, "web");
 }
 function proxyRequest(req, res, targetPort, rewritePath) {
   const targetPath = rewritePath ? rewritePath(req.url || "/") : req.url || "/";
@@ -5609,10 +6399,10 @@ ${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]
+  ${colors.bold}comment${colors.reset}     <id> ["<text>"] [--file <path>] [--text "..."] [--author "..."] [--json]
                Append a research finding, test verification, or note to ticket history.
 
   ${colors.bold}link${colors.reset}        <sourceId> <relation> <targetId> [--author "..."] [--json]
@@ -5661,8 +6451,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 +6466,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 +6478,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), implementation plan (plan), or comment (comment).
   --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 +6544,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 +6552,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 (${path11.basename(warn.firstHub)} and ${path11.basename(warn.duplicateHub)}). Duplicate project codes across hubs are not supported; only '${path11.basename(warn.firstHub)}' is active.${colors.reset}`
     );
   }
 }
@@ -5802,7 +6595,7 @@ async function main() {
     switch (command) {
       case "init": {
         const rawTarget = positionals[0];
-        const targetDir = rawTarget ? path9.resolve(rawTarget) : discovered.workspaceRoot;
+        const targetDir = rawTarget ? path11.resolve(rawTarget) : discovered.workspaceRoot;
         const rawHubFlag = flags["hub"];
         const hubArg = typeof rawHubFlag === "string" ? rawHubFlag : void 0;
         const isHubRequested = Boolean(rawHubFlag);
@@ -5881,7 +6674,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 = fs11.existsSync(path11.join(targetDir, "projects.json")) || fs11.existsSync(path11.join(targetDir, "projects")) && !fs11.existsSync(path11.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 +6745,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 = fs11.readFileSync(viteConfigPath, "utf-8");
             const alreadyConfigured = rawContent.includes("'/esedre'") || rawContent.includes('"/esedre"');
             if (!alreadyConfigured) {
               if (isYes) {
@@ -5962,7 +6755,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}${path11.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 +6771,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 = path11.resolve(expandHome(singleHub));
+          if (fs11.existsSync(resolvedHub)) {
+            const rel = path11.relative(targetDir, resolvedHub).replace(/\\/g, "/");
+            const isSubdir = !rel.startsWith("..") && !path11.isAbsolute(rel);
+            if (isSubdir || Boolean(flags["data-dir"])) {
+              hubRelPath = rel.startsWith(".") ? rel : "./" + rel;
+            }
           }
         }
         const res = initWorkspace(targetDir, {
@@ -6152,7 +6948,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} ${fs11.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 +6980,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] ? path11.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 +7126,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 +7147,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 && fs11.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 +7352,11 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         if (setPlan || filePath) {
           let content = setPlan;
           if (filePath) {
-            if (!fs9.existsSync(filePath)) {
+            if (!fs11.existsSync(filePath)) {
               console.error(`${colors.red}Error: Plan file "${filePath}" not found.${colors.reset}`);
               process.exit(1);
             }
-            content = fs9.readFileSync(filePath, "utf-8");
+            content = fs11.readFileSync(filePath, "utf-8");
           }
           await storage.savePlan(id, content, lastHash);
           if (isJson) {
@@ -6589,8 +7428,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 = path11.resolve(fileArg);
+          if (!fs11.existsSync(filePath)) {
             if (isJson) {
               console.error(JSON.stringify({ error: `Detail file "${fileArg}" not found` }));
             } else {
@@ -6598,7 +7437,7 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
             }
             process.exit(1);
           }
-          detailMarkdown = fs9.readFileSync(filePath, "utf-8");
+          detailMarkdown = fs11.readFileSync(filePath, "utf-8");
         }
         const created = await storage.createTicket({
           title,
@@ -6664,6 +7503,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 = path11.resolve(fileArg);
+          if (!fs11.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(fs11.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));
@@ -6819,10 +7674,30 @@ ${colors.bold}Tickets:${colors.reset}`);
         }
         const projectFlag = flags["project"];
         const lookupKey = projectFlag && /^\d+$/.test(idStr) ? `${projectFlag}-${idStr}` : idStr;
-        const positionalText = positionals.slice(1).join(" ").trim();
-        const text = flags["text"] || (positionalText || void 0);
+        let text;
+        const filePath = flags["file"];
+        if (filePath) {
+          const resolvedPath = path11.resolve(process.cwd(), filePath);
+          if (!fs11.existsSync(resolvedPath)) {
+            console.error(`${colors.red}Error: File not found: ${filePath}${colors.reset}`);
+            process.exit(1);
+          }
+          if (!fs11.statSync(resolvedPath).isFile()) {
+            console.error(`${colors.red}Error: Path is not a file: ${filePath}${colors.reset}`);
+            process.exit(1);
+          }
+          const fileContent = fs11.readFileSync(resolvedPath, "utf-8");
+          if (!fileContent.trim()) {
+            console.error(`${colors.red}Error: Comment file is empty: ${filePath}${colors.reset}`);
+            process.exit(1);
+          }
+          text = fileContent;
+        } else {
+          const positionalText = positionals.slice(1).join(" ").trim();
+          text = flags["text"] || (positionalText || void 0);
+        }
         if (!text) {
-          console.error(`${colors.red}Error: Comment text is required (e.g. ese comment 96 "Verified tests" or --text "...")${colors.reset}`);
+          console.error(`${colors.red}Error: Comment text or --file is required (e.g. ese comment 96 --file note.md or ese comment 96 "Verified tests")${colors.reset}`);
           process.exit(1);
         }
         const author = flags["author"] || "User";