esedre 1.1.0 → 1.3.0

package/dist/esedre.mjs

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 
 // bin/esedre.ts
-import fs10 from "node:fs";
-import path10 from "node:path";
+import fs11 from "node:fs";
+import path11 from "node:path";
 
 // src/storage/filesystem.ts
 import fs3 from "node:fs";
 import path3 from "node:path";
-import os2 from "node:os";
+import os3 from "node:os";
 
 // src/types.ts
-var CURRENT_ESEDRE_VERSION = "1.1.0";
+var CURRENT_ESEDRE_VERSION = "1.3.0";
 var INVERSE_RELATIONS = {
   "relates-to": "relates-to",
   "blocks": "blocked-by",
@@ -20,6 +20,19 @@ var INVERSE_RELATIONS = {
   "duplicates": "duplicated-by",
   "duplicated-by": "duplicates"
 };
+var DEFAULT_LEASE_TTL_MINUTES = 60;
+var EsedreLeaseConflictError = class extends Error {
+  ticketKey;
+  activeLease;
+  constructor(ticketKey, activeLease) {
+    super(
+      `Lease Conflict on Ticket ${ticketKey}: currently leased by '${activeLease.holder}'${activeLease.hostname ? ` on ${activeLease.hostname}` : ""} until ${activeLease.expiresAt}. Pass --force (or force: true) to override.`
+    );
+    this.name = "EsedreLeaseConflictError";
+    this.ticketKey = ticketKey;
+    this.activeLease = activeLease;
+  }
+};
 var EsedreConflictError = class extends Error {
   constructor(ticketId, currentHash, lastHash) {
     super(
@@ -35,10 +48,57 @@ var EsedreConflictError = class extends Error {
   lastHash;
 };
 
+// src/utils/identity.ts
+import os from "node:os";
+import { execSync } from "node:child_process";
+function detectGitBranch(cwd) {
+  try {
+    const out = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: cwd || process.cwd(),
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+      timeout: 1500
+    }).trim();
+    return out && out !== "HEAD" ? out : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveWorkerIdentity(input) {
+  let hostname = input?.hostname?.trim() || "";
+  if (!hostname) {
+    try {
+      hostname = os.hostname() || "local-host";
+    } catch {
+      hostname = "local-host";
+    }
+  }
+  let username = "";
+  try {
+    username = os.userInfo().username || "";
+  } catch {
+    username = process.env.USER || process.env.USERNAME || "developer";
+  }
+  const envHolder = process.env.ESEDRE_WORKER_ID || process.env.ESEDRE_AGENT_ID || process.env.AGY_AGENT_ID || "";
+  const holder = input?.holder?.trim() || envHolder.trim() || input?.configDefaultAuthor?.trim() || `${username}@${hostname}`;
+  const agentType = input?.agentType?.trim() || process.env.ESEDRE_AGENT_TYPE?.trim() || (process.env.AGY_CONVERSATION_ID ? "antigravity" : void 0);
+  const sessionId = input?.sessionId?.trim() || process.env.ESEDRE_SESSION_ID?.trim() || process.env.AGY_CONVERSATION_ID?.trim() || void 0;
+  const worktree = input?.worktree?.trim() || process.cwd();
+  const branch = input?.branch?.trim() || detectGitBranch(worktree);
+  return {
+    holder,
+    ...agentType ? { agentType } : {},
+    hostname,
+    ...sessionId ? { sessionId } : {},
+    ...branch ? { branch } : {},
+    ...worktree ? { worktree } : {}
+  };
+}
+
 // src/config.ts
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
+import os2 from "node:os";
 var DEFAULT_ESEDRE_PORT = 5674;
 var MAX_PROJECT_CODE_LENGTH = 8;
 var PROJECT_CODE_REGEX = /^[a-zA-Z0-9]{1,8}$/;
@@ -113,7 +173,7 @@ function getGlobalConfigDir() {
     return process.env.ESEDRE_GLOBAL_DIR;
   }
   if (process.env.VITEST) {
-    const testGlobalDir = path.join(os.tmpdir(), "esedre-vitest-global");
+    const testGlobalDir = path.join(os2.tmpdir(), "esedre-vitest-global");
     if (!fs.existsSync(testGlobalDir)) {
       try {
         fs.mkdirSync(testGlobalDir, { recursive: true });
@@ -122,7 +182,7 @@ function getGlobalConfigDir() {
     }
     return testGlobalDir;
   }
-  return path.join(os.homedir(), ".esedre");
+  return path.join(os2.homedir(), ".esedre");
 }
 function getGlobalConfigPath() {
   return path.join(getGlobalConfigDir(), "config.json");
@@ -130,7 +190,7 @@ function getGlobalConfigPath() {
 function expandHome(filePath) {
   if (!filePath) return filePath;
   if (filePath === "~" || filePath.startsWith("~/") || filePath.startsWith("~\\")) {
-    return path.join(os.homedir(), filePath.slice(1));
+    return path.join(os2.homedir(), filePath.slice(1));
   }
   return filePath;
 }
@@ -492,7 +552,8 @@ function migrateEsedreConfig(raw, targetVersion = CURRENT_ESEDRE_VERSION) {
     serverUrl: raw?.serverUrl,
     port: typeof raw?.port === "number" && raw.port !== DEFAULT_ESEDRE_PORT ? raw.port : void 0,
     ports: typeof raw?.ports === "object" && raw?.ports ? raw.ports : void 0,
-    projects: typeof raw?.projects === "object" && raw?.projects ? raw.projects : void 0
+    projects: typeof raw?.projects === "object" && raw?.projects ? raw.projects : void 0,
+    defaultAuthor: typeof raw?.defaultAuthor === "string" && raw.defaultAuthor.trim() ? raw.defaultAuthor.trim() : void 0
   };
   return migrated;
 }
@@ -572,6 +633,7 @@ async function generateProjectSnapshot(storage, projectCode, outputDir) {
       inheritedFeatureFlag: ticketObj.meta.inheritedFeatureFlag,
       links: ticketObj.meta.links || [],
       isBlocked: ticketObj.isBlocked || false,
+      ...ticketObj.lease ? { lease: ticketObj.lease } : {},
       hasPlan: Boolean(plan && plan.trim().length > 0),
       planMarkdown: plan && plan.trim().length > 0 ? plan : void 0,
       createdAt,
@@ -607,13 +669,17 @@ async function generateProjectSnapshot(storage, projectCode, outputDir) {
     });
   } catch {
   }
+  const activeLeases = entries.map((e) => e.lease).filter((l) => Boolean(l));
+  const lastTicketId = entries.reduce((max, e) => Math.max(max, e.id), 0);
   const snapshot = {
     version: CURRENT_ESEDRE_VERSION,
     projectCode,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     totalTickets: entries.length,
+    lastTicketId,
     tickets: entries,
-    ...milestoneSnapshots && milestoneSnapshots.length > 0 ? { milestones: milestoneSnapshots } : {}
+    ...milestoneSnapshots && milestoneSnapshots.length > 0 ? { milestones: milestoneSnapshots } : {},
+    ...activeLeases.length > 0 ? { activeLeases } : {}
   };
   const esedreDir = path2.join(outputDir, ".esedre");
   if (!fs2.existsSync(esedreDir)) {
@@ -801,6 +867,14 @@ function formatTicketDetail(ticket) {
   if (ticket.isBlocked) {
     lines.push(`${colors.bold}Dependency:${colors.reset}   ${colors.red}${colors.bold}Blocked by uncompleted ticket${colors.reset}`);
   }
+  if (ticket.lease) {
+    const l = ticket.lease;
+    const hostInfo = l.hostname ? ` on ${l.hostname}` : "";
+    const branchInfo = l.branch ? ` [branch: ${l.branch}]` : "";
+    lines.push(
+      `${colors.bold}Active Lease:${colors.reset} ${colors.cyan}${colors.bold}${l.holder}${colors.reset}${hostInfo}${branchInfo} ${colors.dim}(expires ${l.expiresAt})${colors.reset}`
+    );
+  }
   if (detail?.summary) {
     lines.push("");
     lines.push(`${colors.bold}Summary:${colors.reset}`);
@@ -933,6 +1007,23 @@ function formatMilestoneListTable(milestones, tickets) {
   });
   return [header, divider, ...formattedRows].join("\n");
 }
+function formatLeaseListTable(leases) {
+  if (leases.length === 0) {
+    return `${colors.dim}No active ticket leases.${colors.reset}`;
+  }
+  const lines = [];
+  const header = `${pad("TICKET", 12)} ${pad("HOLDER", 22)} ${pad("HOST / AGENT", 22)} ${pad("BRANCH", 24)} ${pad("EXPIRES AT", 24)}`;
+  lines.push(`${colors.bold}${colors.cyan}${header}${colors.reset}`);
+  lines.push(`${colors.dim}${"-".repeat(108)}${colors.reset}`);
+  for (const l of leases) {
+    const hostAgent = [l.hostname, l.agentType].filter(Boolean).join(" / ") || "-";
+    const branch = l.branch || "-";
+    lines.push(
+      `${colors.bold}${pad(l.ticketKey, 12)}${colors.reset} ${colors.green}${pad(l.holder.slice(0, 20), 22)}${colors.reset} ${pad(hostAgent.slice(0, 20), 22)} ${colors.cyan}${pad(branch.slice(0, 22), 24)}${colors.reset} ${colors.dim}${pad(l.expiresAt, 24)}${colors.reset}`
+    );
+  }
+  return lines.join("\n");
+}
 
 // src/storage/filesystem.ts
 function isProjectMatch(code, filter) {
@@ -1865,7 +1956,7 @@ ${formattedList}`
       } catch {
       }
     }
-    const globalConfigFile = path3.join(os2.homedir(), ".esedre", "config.json");
+    const globalConfigFile = path3.join(os3.homedir(), ".esedre", "config.json");
     if (fs3.existsSync(globalConfigFile)) {
       try {
         const gCfg = JSON.parse(fs3.readFileSync(globalConfigFile, "utf-8"));
@@ -2202,7 +2293,8 @@ ${formattedList}`
       "implementation_plan.md",
       "comments.json",
       "answers.json",
-      "inline-comments.json"
+      "inline-comments.json",
+      "lease.json"
     ];
     const currentStats = {};
     for (const f of filesToCheck) {
@@ -2230,14 +2322,34 @@ ${formattedList}`
         }
         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);
+          if (ticket.lease) {
+            const expMs = Date.parse(ticket.lease.expiresAt);
+            if (!isNaN(expMs) && expMs <= Date.now()) {
+              try {
+                fs3.unlinkSync(path3.join(ticketDir, "lease.json"));
+              } catch {
+              }
+              this.ticketMemoryCache.delete(resolvedTicketDir);
+            } else {
+              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;
+            }
+          } else {
+            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;
           }
-          return ticket;
         }
       }
     }
@@ -2313,6 +2425,32 @@ ${formattedList}`
         } catch {
         }
       }
+      let lease = null;
+      const leasePath = path3.join(ticketDir, "lease.json");
+      if (currentStats["lease.json"]) {
+        try {
+          const parsedLease = JSON.parse(fs3.readFileSync(leasePath, "utf-8"));
+          const expMs = Date.parse(parsedLease.expiresAt);
+          if (!isNaN(expMs) && expMs <= Date.now()) {
+            try {
+              fs3.unlinkSync(leasePath);
+              delete currentStats["lease.json"];
+            } catch {
+            }
+          } else {
+            parsedLease.project = effectiveLoc.project.code;
+            parsedLease.ticketId = meta.id;
+            parsedLease.ticketKey = `${effectiveLoc.project.code}-${meta.id}`;
+            lease = parsedLease;
+          }
+        } catch {
+        }
+      }
+      if (lease) {
+        meta.lease = lease;
+      } else {
+        delete meta.lease;
+      }
       const ticketObj = {
         meta,
         detail,
@@ -2320,6 +2458,7 @@ ${formattedList}`
         comments,
         answers,
         inlineComments,
+        lease,
         projectDescriptor: effectiveLoc.project
       };
       normalizeTicketFields(ticketObj);
@@ -2450,6 +2589,18 @@ ${formattedList}`
             continue;
           }
         }
+        if (filter?.leased !== void 0) {
+          const hasActiveLease = Boolean(ticketObj.lease);
+          if (hasActiveLease !== Boolean(filter.leased)) {
+            continue;
+          }
+        }
+        if (filter?.leasedBy) {
+          const holderFilter = filter.leasedBy.trim().toLowerCase();
+          if (!ticketObj.lease || ticketObj.lease.holder.toLowerCase() !== holderFilter) {
+            continue;
+          }
+        }
         tickets.push(ticketObj);
       }
       const locResolvedDir = path3.resolve(loc.ticketsDir);
@@ -2483,7 +2634,7 @@ ${formattedList}`
     const category = type;
     const complexityMatch = raw.match(/\*\*Complexity\*\*:\s*([^\n]+)/i);
     const complexity = complexityMatch ? complexityMatch[1].trim() : "Medium";
-    const effortMatch = raw.match(/\*\*Estimated Effort\*\*:\s*([^\n]+)/i);
+    const effortMatch = raw.match(/\*\*(?:Estimated\s+)?Effort\*\*:\s*([^\n]+)/i);
     const estimatedEffort = effortMatch ? effortMatch[1].trim() : "2.0 - 4.0 hours";
     let summary;
     const summaryMatch = raw.match(/(?:##|###)\s*(?:Summary|Rationale)\s*\n([\s\S]*?)(?=\n##|\n###|\n#|$)/i);
@@ -2491,30 +2642,86 @@ ${formattedList}`
       summary = summaryMatch[1].trim();
     }
     const breakdown = [];
-    const breakdownMatch = raw.match(/(?:##|###)\s*Feature Breakdown\s*\n([\s\S]*?)(?=\n##|\n###|\n#|$)/i);
+    const breakdownMatch = raw.match(/(?:##|###)\s*(?:Feature|Task|Fix|Implementation)\s+Breakdown\s*\n([\s\S]*?)(?=\n##|\n###|\n#|$)/i);
     if (breakdownMatch) {
       const lines = breakdownMatch[1].split("\n");
+      let currentItem = "";
       for (const line of lines) {
-        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-)\s+(.*)/);
-        if (itemMatch) breakdown.push(itemMatch[1].trim());
+        const numberedMatch = line.match(/^\s*\d+\.\s+(.*)$/);
+        if (numberedMatch) {
+          if (currentItem) breakdown.push(currentItem);
+          currentItem = numberedMatch[1].trim();
+        } else if (/^\s*[-*•]\s+/.test(line)) {
+          const bulletText = line.trim().replace(/^[-*•]\s+/, "").trim();
+          if (/^\s{2,}[-*•]\s+/.test(line) && currentItem) {
+            currentItem += "\n  - " + bulletText;
+          } else {
+            if (currentItem) {
+              breakdown.push(currentItem);
+              currentItem = "";
+            }
+            breakdown.push(bulletText);
+          }
+        } else if (currentItem && line.trim()) {
+          currentItem += " " + line.trim();
+        }
       }
+      if (currentItem) breakdown.push(currentItem);
     }
     const technicalDetails = [];
-    const techMatch = raw.match(/###\s*(?:Technical Details?|Architecture)\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|$)/i);
+    const openQuestions = [];
+    const combinedMatch = raw.match(/(?:##|###)\s*Technical Details?\s*&\s*Open Questions?\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|\n#|$)/i);
+    if (combinedMatch) {
+      const lines = combinedMatch[1].split("\n");
+      for (const line of lines) {
+        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-|•)\s+(.*)/);
+        if (!itemMatch) continue;
+        const content = itemMatch[1].trim();
+        if (!content) continue;
+        if (/^\*\*Open Questions?\*\*:\s*/i.test(content)) {
+          const q = content.replace(/^\*\*Open Questions?\*\*:\s*/i, "").trim();
+          if (q && !/^(?:None|None recorded at initialization|N\/A)\.?$/i.test(q)) {
+            openQuestions.push(q);
+          }
+        } else {
+          const td = content.replace(/^\*\*Technical Details?\*\*:\s*/i, "").trim();
+          if (td && !/^Architecture specifications to be documented\.?$/i.test(td)) {
+            technicalDetails.push(td);
+          }
+        }
+      }
+    }
+    const techMatch = raw.match(/(?:##|###)\s*(?:Technical Details?(?!\s*&\s*Open Questions?)(?:\s*&\s*Architecture)?|Architecture)\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|\n#|$)/i);
     if (techMatch) {
       const lines = techMatch[1].split("\n");
       for (const line of lines) {
-        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-)\s+(.*)/);
-        if (itemMatch) technicalDetails.push(itemMatch[1].trim());
+        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-|•)\s+(.*)/);
+        if (!itemMatch) continue;
+        const content = itemMatch[1].trim();
+        if (!content) continue;
+        if (/^\*\*Open Questions?\*\*:\s*/i.test(content)) {
+          const q = content.replace(/^\*\*Open Questions?\*\*:\s*/i, "").trim();
+          if (q && !/^(?:None|None recorded at initialization|N\/A)\.?$/i.test(q)) {
+            openQuestions.push(q);
+          }
+        } else {
+          const td = content.replace(/^\*\*Technical Details?\*\*:\s*/i, "").trim();
+          if (td && !/^Architecture specifications to be documented\.?$/i.test(td)) {
+            technicalDetails.push(td);
+          }
+        }
       }
     }
-    const openQuestions = [];
-    const questionsMatch = raw.match(/###\s*(?:Open Questions?|Technical Detail & Open Questions?|Decisions)\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|$)/i);
+    const questionsMatch = raw.match(/(?:##|###)\s*(?:Open Questions?(?:\s*&\s*Decisions)?|Decisions)\s*\n+([\s\S]*?)(?=\n###|\n---|\n##|\n#|$)/i);
     if (questionsMatch) {
       const lines = questionsMatch[1].split("\n");
       for (const line of lines) {
-        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-)\s+(.*)/);
-        if (itemMatch) openQuestions.push(itemMatch[1].trim());
+        const itemMatch = line.match(/^\s*(?:\d+\.|\*|-|•)\s+(.*)/);
+        if (!itemMatch) continue;
+        const content = itemMatch[1].trim().replace(/^\*\*Open Questions?\*\*:\s*/i, "").trim();
+        if (content && !/^(?:None|None recorded at initialization|N\/A)\.?$/i.test(content)) {
+          openQuestions.push(content);
+        }
       }
     }
     const priorityMatch = raw.match(/\*\*Priority\*\*:\s*([^\n]+)/i);
@@ -2533,6 +2740,101 @@ ${formattedList}`
       raw
     };
   }
+  reconcileDetailMetadataHeaders(content, meta, updates, syncAll = false) {
+    const sectionSplitMatch = content.match(/\n(?=(?:##|###)\s+)/);
+    const splitIdx = sectionSplitMatch && sectionSplitMatch.index !== void 0 ? sectionSplitMatch.index : content.length;
+    let preamble = content.slice(0, splitIdx);
+    const bodySection = content.slice(splitIdx);
+    const replaceAndDedupeLine = (text, lineRegex, formatReplacement) => {
+      let seen = false;
+      const next = text.replace(lineRegex, (_full, lead = "", label = "") => {
+        if (!seen) {
+          seen = true;
+          return formatReplacement(lead, label);
+        }
+        return "__ESEDRE_DEDUPE_REMOVE__";
+      });
+      return {
+        text: next.replace(/\n?__ESEDRE_DEDUPE_REMOVE__[ \t]*\r?/g, ""),
+        matched: seen
+      };
+    };
+    if (syncAll || updates?.title) {
+      preamble = preamble.replace(
+        /^#\s*(?:Ticket\s*#?\d+\s*:\s*|\d+\s*:\s*)?[^\n]+/im,
+        `# Ticket #${meta.id}: ${meta.title}`
+      );
+    }
+    if (syncAll || updates?.type || updates?.category) {
+      const effectiveType = meta.type || meta.category;
+      const preferTypeLabel = Boolean(updates?.type || updates?.category);
+      preamble = replaceAndDedupeLine(
+        preamble,
+        /^([ \t]*(?:[-*•]\s+)?)\*\*(Type|Category)\*\*:\s*[^\n\r]*/gim,
+        (lead, label) => `${lead}**${preferTypeLabel ? "Type" : label}**: ${effectiveType}${lead.trim() ? "" : "  "}`
+      ).text;
+    }
+    if (syncAll || updates?.status) {
+      preamble = replaceAndDedupeLine(
+        preamble,
+        /^([ \t]*(?:[-*•]\s+)?)\*\*(Status)\*\*:\s*[^\n\r]*/gim,
+        (lead) => `${lead}**Status**: ${meta.status}${lead.trim() ? "" : "  "}`
+      ).text;
+    }
+    if (syncAll || updates && "priority" in updates) {
+      if (meta.priority) {
+        const res = replaceAndDedupeLine(
+          preamble,
+          /^([ \t]*(?:[-*•]\s+)?)\*\*(Priority)\*\*:\s*[^\n\r]*/gim,
+          (lead) => `${lead}**Priority**: ${meta.priority}${lead.trim() ? "" : "  "}`
+        );
+        preamble = res.text;
+        if (!res.matched && /\*\*(?:Type|Category)\*\*:\s*[^\n]+/i.test(preamble)) {
+          preamble = preamble.replace(
+            /^([ \t]*(?:[-*•]\s+)?\*\*(?:Type|Category)\*\*:\s*[^\n\r]*)/im,
+            `$1
+**Priority**: ${meta.priority}  `
+          );
+        }
+      } else {
+        preamble = preamble.replace(/^[ \t]*(?:[-*•]\s+)?\*\*Priority\*\*:\s*[^\n\r]*\r?\n?/gim, "");
+      }
+    }
+    if (syncAll || updates && "milestone" in updates) {
+      if (meta.milestone) {
+        const res = replaceAndDedupeLine(
+          preamble,
+          /^([ \t]*(?:[-*•]\s+)?)\*\*(Milestone)\*\*:\s*[^\n\r]*/gim,
+          (lead) => `${lead}**Milestone**: ${meta.milestone}${lead.trim() ? "" : "  "}`
+        );
+        preamble = res.text;
+        if (!res.matched && /\*\*(?:Priority|Type|Category)\*\*:\s*[^\n]+/i.test(preamble)) {
+          preamble = preamble.replace(
+            /^([ \t]*(?:[-*•]\s+)?\*\*(?:Priority|Type|Category)\*\*:\s*[^\n\r]*)/im,
+            `$1
+**Milestone**: ${meta.milestone}  `
+          );
+        }
+      } else {
+        preamble = preamble.replace(/^[ \t]*(?:[-*•]\s+)?\*\*Milestone\*\*:\s*[^\n\r]*\r?\n?/gim, "");
+      }
+    }
+    if (syncAll || updates?.complexity) {
+      preamble = replaceAndDedupeLine(
+        preamble,
+        /^([ \t]*(?:[-*•]\s+)?)\*\*(Complexity)\*\*:\s*[^\n\r]*/gim,
+        (lead) => `${lead}**Complexity**: ${meta.complexity}${lead.trim() ? "" : "  "}`
+      ).text;
+    }
+    if (syncAll || updates?.estimatedEffort) {
+      preamble = replaceAndDedupeLine(
+        preamble,
+        /^([ \t]*(?:[-*•]\s+)?)\*\*((?:Estimated\s+)?Effort)\*\*:\s*[^\n\r]*/gim,
+        (lead, label) => `${lead}**${label || "Estimated Effort"}**: ${meta.estimatedEffort}${lead.trim() ? "" : "  "}`
+      ).text;
+    }
+    return preamble + bodySection;
+  }
   formatTicketDetailMarkdown(rawDetail, meta, fallbackSummary) {
     const trimmed = rawDetail.trim();
     const priorityLine = meta.priority ? `**Priority**: ${meta.priority}  
@@ -2541,26 +2843,37 @@ ${formattedList}`
 ` : "";
     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 preambleCheck = processed.split(/\n(?=(?:##|###)\s+)/)[0];
+      const hasAnyMetaLine = /\*\*(?:Type|Category|Priority|Milestone|Complexity|(?:Estimated\s+)?Effort|Status)\*\*:/i.test(
+        preambleCheck
+      );
+      if (!hasAnyMetaLine) {
         const metaBlock = `
 **Category**: ${meta.category}  
 ${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
 **Estimated Effort**: ${meta.estimatedEffort}  
 `;
         processed = processed.replace(/^(# Ticket[^\n]+\n)/m, `$1${metaBlock}`);
+      } else if (!/\*\*(?:Type|Category)\*\*:/i.test(preambleCheck)) {
+        processed = processed.replace(/^(# Ticket[^\n]+\n)/m, `$1**Category**: ${meta.category}  
+`);
       }
+      processed = this.reconcileDetailMetadataHeaders(processed, meta, void 0, true);
       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}`);
+        processed = processed.replace(
+          /^((?:# Ticket[^\n]+\n)(?:[ \t]*(?:[-*•]\s+)?\*\*[^\n]+\n|\s*\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);
+    const hasBreakdown = /(?:##|###)\s*(?:Feature|Task|Fix|Implementation)\s+Breakdown/i.test(trimmed);
     let body = "";
     if (!hasSummary) {
       body += `### Summary
@@ -2767,7 +3080,17 @@ ${input.summary || "Summary to be defined."}
         }
       }
     }
+    delete updatedMeta.lease;
     writeSafeFile(metaPath, JSON.stringify(updatedMeta, null, 2) + "\n");
+    if (updates.status === "Completed" || updates.status === "Rejected") {
+      const leasePath = path3.join(locInfo.ticketDir, "lease.json");
+      if (fs3.existsSync(leasePath)) {
+        try {
+          fs3.unlinkSync(leasePath);
+        } catch {
+        }
+      }
+    }
     const newType = updates.type || updates.category;
     if (newType) {
       updatedMeta.type = newType;
@@ -2777,74 +3100,15 @@ ${input.summary || "Summary to be defined."}
     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}`);
-      }
+      content = this.reconcileDetailMetadataHeaders(content, updatedMeta, updates, true);
       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}`);
-      }
-      if (updates.type || updates.category) {
-        content = content.replace(/\*\*(?:Type|Category)\*\*:\s*[^\n]+/i, `**Type**: ${updatedMeta.type}`);
-      }
-      if ("priority" in updates) {
-        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 {
-          content = content.replace(/\*\*Priority\*\*:\s*[^\n]+\n?/i, "");
-        }
-      }
-      if ("milestone" in updates) {
-        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 {
-          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}`);
-      }
+    } else if (existing.detail && ("priority" in updates || "milestone" in updates || updates.status || updates.title || updates.type || updates.category || updates.complexity || updates.estimatedEffort)) {
+      const content = this.reconcileDetailMetadataHeaders(
+        existing.detail.raw,
+        updatedMeta,
+        updates,
+        false
+      );
       writeSafeFile(path3.join(locInfo.ticketDir, "detail.md"), content);
     }
     this.invalidateTicketCache(locInfo.ticketDir);
@@ -3280,6 +3544,163 @@ ${input.summary || "Summary to be defined."}
     const updatedSource = await this.getTicket(sourceInfo.key);
     return { source: updatedSource, target: updatedTarget };
   }
+  readValidLeaseFromDir(ticketDir, projectCode, ticketId) {
+    const leasePath = path3.join(ticketDir, "lease.json");
+    if (!fs3.existsSync(leasePath)) return null;
+    try {
+      const parsed = JSON.parse(fs3.readFileSync(leasePath, "utf-8"));
+      const expMs = Date.parse(parsed.expiresAt);
+      if (!isNaN(expMs) && expMs <= Date.now()) {
+        try {
+          fs3.unlinkSync(leasePath);
+        } catch {
+        }
+        this.invalidateTicketCache(ticketDir);
+        return null;
+      }
+      parsed.project = projectCode;
+      parsed.ticketId = ticketId;
+      parsed.ticketKey = `${projectCode}-${ticketId}`;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  async claimTicket(input) {
+    const resolved = this.resolveTicketIdentifier(input.ticketId, input.project || this.config.projectCode);
+    if (!resolved) {
+      throw new Error(`Ticket #${input.ticketId} could not be located.`);
+    }
+    const identity = resolveWorkerIdentity({
+      holder: input.holder,
+      agentType: input.agentType,
+      hostname: input.hostname,
+      sessionId: input.sessionId,
+      branch: input.branch,
+      worktree: input.worktree || this.workspaceRoot,
+      configDefaultAuthor: this.config.defaultAuthor
+    });
+    const ttlMinutes = typeof input.ttlMinutes === "number" && input.ttlMinutes > 0 ? Math.min(Math.max(1, Math.round(input.ttlMinutes)), 24 * 60) : DEFAULT_LEASE_TTL_MINUTES;
+    const existingLease = this.readValidLeaseFromDir(resolved.ticketDir, resolved.project, resolved.id);
+    let renewed = false;
+    let overridden = false;
+    if (existingLease) {
+      const isSameHolder = existingLease.holder.toLowerCase() === identity.holder.toLowerCase();
+      if (!isSameHolder && !input.force) {
+        throw new EsedreLeaseConflictError(resolved.key, existingLease);
+      }
+      if (isSameHolder) {
+        renewed = true;
+      } else {
+        overridden = true;
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const expiresIso = new Date(now.getTime() + ttlMinutes * 60 * 1e3).toISOString();
+    const lease = {
+      ticketId: resolved.id,
+      ticketKey: resolved.key,
+      project: resolved.project,
+      holder: normalizeDashesAndMojibake(identity.holder),
+      ...identity.agentType ? { agentType: normalizeDashesAndMojibake(identity.agentType) } : {},
+      ...identity.hostname ? { hostname: normalizeDashesAndMojibake(identity.hostname) } : {},
+      ...identity.sessionId ? { sessionId: normalizeDashesAndMojibake(identity.sessionId) } : {},
+      ...identity.branch ? { branch: normalizeDashesAndMojibake(identity.branch) } : {},
+      ...identity.worktree ? { worktree: identity.worktree } : {},
+      claimedAt: renewed && existingLease ? existingLease.claimedAt : nowIso,
+      renewedAt: nowIso,
+      expiresAt: expiresIso,
+      ttlMinutes
+    };
+    const leasePath = path3.join(resolved.ticketDir, "lease.json");
+    writeSafeFile(leasePath, JSON.stringify(lease, null, 2) + "\n");
+    this.invalidateTicketCache(resolved.ticketDir);
+    let ticket = await this.getTicket(resolved.key);
+    const targetStatus = input.statusOnClaim ?? (ticket.meta.status === "Planned" ? "In Development" : void 0);
+    if (targetStatus && ticket.meta.status !== targetStatus) {
+      ticket = await this.updateTicket(resolved.key, {
+        status: targetStatus,
+        isActivePlanning: targetStatus === "In Development" ? true : ticket.meta.isActivePlanning
+      });
+    }
+    return {
+      lease,
+      ticket,
+      renewed,
+      ...overridden ? { overridden: true } : {}
+    };
+  }
+  async renewLease(input) {
+    const resolved = this.resolveTicketIdentifier(input.ticketId, input.project || this.config.projectCode);
+    if (!resolved) {
+      throw new Error(`Ticket #${input.ticketId} could not be located.`);
+    }
+    const existingLease = this.readValidLeaseFromDir(resolved.ticketDir, resolved.project, resolved.id);
+    if (!existingLease) {
+      throw new Error(`Ticket ${resolved.key} does not have an active lease to renew.`);
+    }
+    if (input.holder && !input.force) {
+      const requestedHolder = input.holder.trim().toLowerCase();
+      if (existingLease.holder.toLowerCase() !== requestedHolder) {
+        throw new EsedreLeaseConflictError(resolved.key, existingLease);
+      }
+    }
+    const ttlMinutes = typeof input.ttlMinutes === "number" && input.ttlMinutes > 0 ? Math.min(Math.max(1, Math.round(input.ttlMinutes)), 24 * 60) : existingLease.ttlMinutes || DEFAULT_LEASE_TTL_MINUTES;
+    const now = /* @__PURE__ */ new Date();
+    const updatedLease = {
+      ...existingLease,
+      ...input.holder ? { holder: normalizeDashesAndMojibake(input.holder.trim()) } : {},
+      renewedAt: now.toISOString(),
+      expiresAt: new Date(now.getTime() + ttlMinutes * 60 * 1e3).toISOString(),
+      ttlMinutes
+    };
+    const leasePath = path3.join(resolved.ticketDir, "lease.json");
+    writeSafeFile(leasePath, JSON.stringify(updatedLease, null, 2) + "\n");
+    this.invalidateTicketCache(resolved.ticketDir);
+    return updatedLease;
+  }
+  async releaseTicket(input) {
+    const resolved = this.resolveTicketIdentifier(input.ticketId, input.project || this.config.projectCode);
+    if (!resolved) {
+      throw new Error(`Ticket #${input.ticketId} could not be located.`);
+    }
+    const existingLease = this.readValidLeaseFromDir(resolved.ticketDir, resolved.project, resolved.id);
+    if (!existingLease) {
+      return { released: false, ticketKey: resolved.key };
+    }
+    if (input.holder && !input.force) {
+      const requestedHolder = input.holder.trim().toLowerCase();
+      if (existingLease.holder.toLowerCase() !== requestedHolder) {
+        throw new EsedreLeaseConflictError(resolved.key, existingLease);
+      }
+    }
+    const leasePath = path3.join(resolved.ticketDir, "lease.json");
+    if (fs3.existsSync(leasePath)) {
+      try {
+        fs3.unlinkSync(leasePath);
+      } catch {
+      }
+    }
+    this.invalidateTicketCache(resolved.ticketDir);
+    return {
+      released: true,
+      ticketKey: resolved.key,
+      previousLease: existingLease
+    };
+  }
+  async getTicketLease(id, projectCode) {
+    const resolved = this.resolveTicketIdentifier(id, projectCode || this.config.projectCode);
+    if (!resolved) return null;
+    return this.readValidLeaseFromDir(resolved.ticketDir, resolved.project, resolved.id);
+  }
+  async listLeases(projectCode) {
+    const tickets = await this.listTickets({
+      project: projectCode === "all" ? void 0 : projectCode,
+      leased: true
+    });
+    return tickets.map((t) => t.lease).filter((l) => Boolean(l));
+  }
 };
 
 // src/securityFilter.ts
@@ -3576,9 +3997,64 @@ var SecurityFilter = class {
     }
     return this.target.getAttachmentPath ? this.target.getAttachmentPath(id, filename) : null;
   }
+  async claimTicket(input) {
+    if (input.project && !isProjectAuthorized(input.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(input.project);
+    }
+    const ticket = await this.getTicket(
+      input.project && /^\d+$/.test(String(input.ticketId).trim()) ? `${input.project}-${input.ticketId}` : input.ticketId
+    );
+    if (!ticket) {
+      throw new Error(`Ticket #${input.ticketId} not found`);
+    }
+    return this.target.claimTicket(input);
+  }
+  async renewLease(input) {
+    if (input.project && !isProjectAuthorized(input.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(input.project);
+    }
+    const ticket = await this.getTicket(
+      input.project && /^\d+$/.test(String(input.ticketId).trim()) ? `${input.project}-${input.ticketId}` : input.ticketId
+    );
+    if (!ticket) {
+      throw new Error(`Ticket #${input.ticketId} not found`);
+    }
+    return this.target.renewLease(input);
+  }
+  async releaseTicket(input) {
+    if (input.project && !isProjectAuthorized(input.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(input.project);
+    }
+    const ticket = await this.getTicket(
+      input.project && /^\d+$/.test(String(input.ticketId).trim()) ? `${input.project}-${input.ticketId}` : input.ticketId
+    );
+    if (!ticket) {
+      throw new Error(`Ticket #${input.ticketId} not found`);
+    }
+    return this.target.releaseTicket(input);
+  }
+  async getTicketLease(id, projectCode) {
+    if (projectCode && !isProjectAuthorized(projectCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(projectCode);
+    }
+    const ticket = await this.getTicket(
+      projectCode && /^\d+$/.test(String(id).trim()) ? `${projectCode}-${id}` : id
+    );
+    if (!ticket) return null;
+    return this.target.getTicketLease(id, projectCode);
+  }
+  async listLeases(projectCode) {
+    if (projectCode && projectCode !== "all" && !isProjectAuthorized(projectCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(projectCode);
+    }
+    const allLeases = await this.target.listLeases(projectCode);
+    return allLeases.filter((l) => isProjectAuthorized(l.project, this.config.allowedProjects));
+  }
 };
 
 // src/mcp/server.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
 import readline from "node:readline";
 var EsedreMcpServer = class {
   storage;
@@ -3689,6 +4165,20 @@ var EsedreMcpServer = class {
               }
             };
           }
+          if (err instanceof EsedreLeaseConflictError || err.name === "EsedreLeaseConflictError") {
+            return {
+              jsonrpc: "2.0",
+              id,
+              error: {
+                code: -32001,
+                message: err.message,
+                data: {
+                  ticketKey: err.ticketKey,
+                  activeLease: err.activeLease
+                }
+              }
+            };
+          }
           return {
             jsonrpc: "2.0",
             id,
@@ -3800,7 +4290,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" }
           }
         }
       },
@@ -3892,9 +4383,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"]
         }
       },
       {
@@ -3983,6 +4475,71 @@ Status: ${ticket.meta.status}`;
           },
           required: ["sourceTicketId", "targetTicketId"]
         }
+      },
+      {
+        name: "esedre_claim_ticket",
+        description: "Claim an advisory TTL-backed lease on a ticket to coordinate multi-agent and multi-machine work and prevent duplicate effort.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: ["number", "string"], description: 'Ticket ID or prefixed key (e.g. 69 or "Esedre-69")' },
+            holder: { type: "string", description: 'Agent or developer identity claiming the ticket (e.g. "agy-subagent-1" or "desktop-worker")' },
+            workerId: { type: "string", description: "Alias for holder: agent or worker identity claiming the ticket" },
+            agentType: { type: "string", description: 'Optional agent runtime identifier (e.g. "antigravity", "claude-code", "codex")' },
+            system: { type: "string", description: "Alias for agentType: system or runtime identifier" },
+            sessionId: { type: "string", description: "Optional conversation or session identifier" },
+            branch: { type: "string", description: "Optional Git branch associated with the lease" },
+            ttlMinutes: { type: "number", description: "Lease time-to-live in minutes (default: 60)" },
+            force: { type: "boolean", description: "Override an existing active lease held by another worker" },
+            project: { type: "string", description: "Optional project code when numeric ticketId is used" }
+          },
+          required: ["ticketId"]
+        }
+      },
+      {
+        name: "esedre_renew_lease",
+        description: "Renew (heartbeat) an active ticket lease to extend its expiration timestamp.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: ["number", "string"], description: "Ticket ID or prefixed key" },
+            holder: { type: "string", description: "Holder identity verifying lease ownership" },
+            workerId: { type: "string", description: "Alias for holder: worker identity verifying lease ownership" },
+            system: { type: "string", description: "Optional system or agent runtime identifier" },
+            ttlMinutes: { type: "number", description: "New TTL in minutes from now (default: 60)" },
+            force: { type: "boolean", description: "Force renewal even if held by another identity" },
+            project: { type: "string", description: "Optional project code" }
+          },
+          required: ["ticketId"]
+        }
+      },
+      {
+        name: "esedre_release_ticket",
+        description: "Release an active lease on a ticket when work is paused, handed off, or completed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ticketId: { type: ["number", "string"], description: "Ticket ID or prefixed key" },
+            holder: { type: "string", description: "Holder identity verifying lease ownership" },
+            workerId: { type: "string", description: "Alias for holder: worker identity verifying lease ownership" },
+            system: { type: "string", description: "Optional system or agent runtime identifier" },
+            finalStatus: { type: "string", enum: ["Planned", "In Development", "Completed", "Rejected"], description: "Optional status to transition the ticket to upon release" },
+            notes: { type: "string", description: "Optional verification or handoff comment to append upon release" },
+            force: { type: "boolean", description: "Force release even if held by another identity" },
+            project: { type: "string", description: "Optional project code" }
+          },
+          required: ["ticketId"]
+        }
+      },
+      {
+        name: "esedre_list_leases",
+        description: "List all currently active (non-expired) ticket leases across authorized projects.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: 'Optional project code filter (or "all")' }
+          }
+        }
       }
     ];
   }
@@ -3991,6 +4548,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,
@@ -4002,23 +4560,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);
@@ -4077,8 +4651,26 @@ Status: ${ticket.meta.status}`;
       }
       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;
@@ -4140,26 +4732,117 @@ Status: ${ticket.meta.status}`;
           target: result.target
         };
       }
+      case "claim_ticket": {
+        const identity = resolveWorkerIdentity({
+          holder: args.holder || args.workerId,
+          agentType: args.agentType || args.system || "mcp-agent",
+          sessionId: args.sessionId,
+          branch: args.branch
+        });
+        const res = await this.storage.claimTicket({
+          ticketId: this.parseTicketId(args.ticketId),
+          holder: identity.holder,
+          agentType: identity.agentType,
+          hostname: identity.hostname,
+          sessionId: identity.sessionId,
+          branch: identity.branch,
+          worktree: identity.worktree,
+          ttlMinutes: args.ttlMinutes,
+          force: Boolean(args.force),
+          project: args.project
+        });
+        return {
+          success: true,
+          renewed: res.renewed,
+          overridden: res.overridden || false,
+          lease: res.lease,
+          ticket: {
+            id: res.ticket.meta.id,
+            project: res.ticket.meta.project,
+            title: res.ticket.meta.title,
+            status: res.ticket.meta.status,
+            sha1: res.ticket.sha1
+          }
+        };
+      }
+      case "renew_lease": {
+        const lease = await this.storage.renewLease({
+          ticketId: this.parseTicketId(args.ticketId),
+          holder: args.holder || args.workerId,
+          ttlMinutes: args.ttlMinutes,
+          force: Boolean(args.force),
+          project: args.project
+        });
+        return {
+          success: true,
+          lease
+        };
+      }
+      case "release_ticket": {
+        const holder = args.holder || args.workerId;
+        const parsedId = this.parseTicketId(args.ticketId);
+        const res = await this.storage.releaseTicket({
+          ticketId: parsedId,
+          holder,
+          force: Boolean(args.force),
+          project: args.project
+        });
+        if (args.finalStatus) {
+          await this.storage.updateTicket(res.ticketKey || parsedId, { status: args.finalStatus });
+        }
+        if (args.notes) {
+          await this.storage.addComment(res.ticketKey || parsedId, {
+            author: holder || res.previousLease?.holder || "mcp-agent",
+            text: args.notes
+          });
+        }
+        return {
+          success: true,
+          ...res
+        };
+      }
+      case "list_leases": {
+        const leases = await this.storage.listLeases(args.project);
+        return {
+          total: leases.length,
+          leases
+        };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
   }
 };
 
+// src/utils/logger.ts
+var MAX_LOG_FILE_BYTES = 5 * 1024 * 1024;
+var debugEnabled = Boolean(process.env.ESEDRE_DEBUG);
+var logFileOverride;
+function initLogger(options) {
+  if (options?.debug !== void 0) {
+    debugEnabled = options.debug;
+  } else if (process.env.ESEDRE_DEBUG) {
+    debugEnabled = true;
+  }
+  if (options?.logFile) {
+    logFileOverride = options.logFile;
+  }
+}
+
 // 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();
@@ -4175,15 +4858,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();
@@ -4200,10 +4883,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>/);
@@ -4222,10 +4905,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 {
@@ -4238,10 +4921,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();
@@ -4255,10 +4938,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();
@@ -4272,10 +4955,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();
@@ -4289,10 +4972,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();
@@ -4306,10 +4989,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();
@@ -4333,48 +5016,49 @@ 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 os5 from "node:os";
+import path7 from "node:path";
 
 // src/server/daemon.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
-import os3 from "node:os";
+import fs6 from "node:fs";
+import path6 from "node:path";
+import os4 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(os4.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 {
         }
       }
@@ -4389,10 +5073,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 {
     }
@@ -4401,32 +5085,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;
@@ -4497,7 +5181,7 @@ async function startDaemon(options = {}) {
       }
     }
     try {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
     } catch {
     }
   }
@@ -4516,40 +5200,40 @@ async function startDaemon(options = {}) {
     };
   }
   resolveStoreDir(workspaceRoot);
-  fs5.mkdirSync(path5.dirname(logFile), { recursive: true });
-  fs5.mkdirSync(path5.dirname(stateFile), { recursive: true });
+  fs6.mkdirSync(path6.dirname(logFile), { recursive: true });
+  fs6.mkdirSync(path6.dirname(stateFile), { recursive: true });
   const MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
   try {
-    if (fs5.existsSync(logFile)) {
-      const stats = fs5.statSync(logFile);
+    if (fs6.existsSync(logFile)) {
+      const stats = fs6.statSync(logFile);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const oldLogFile = `${logFile}.old`;
         try {
-          if (fs5.existsSync(oldLogFile)) fs5.unlinkSync(oldLogFile);
-          fs5.renameSync(logFile, oldLogFile);
+          if (fs6.existsSync(oldLogFile)) fs6.unlinkSync(oldLogFile);
+          fs6.renameSync(logFile, oldLogFile);
         } catch {
-          fs5.truncateSync(logFile, 0);
+          fs6.truncateSync(logFile, 0);
         }
       }
     }
   } catch {
   }
-  const logFd = fs5.openSync(logFile, "a");
-  const isEsedreArgv1 = process.argv[1] && /esedre/i.test(path5.basename(process.argv[1]));
+  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)], {
@@ -4561,7 +5245,7 @@ async function startDaemon(options = {}) {
   });
   child.unref();
   try {
-    fs5.closeSync(logFd);
+    fs6.closeSync(logFd);
   } catch {
   }
   const pid = child.pid;
@@ -4602,13 +5286,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 {
     }
   }
@@ -4671,8 +5355,8 @@ async function stopDaemon(options = {}) {
     }
   }
   try {
-    if (fs5.existsSync(stateFile)) {
-      fs5.unlinkSync(stateFile);
+    if (fs6.existsSync(stateFile)) {
+      fs6.unlinkSync(stateFile);
     }
   } catch {
   }
@@ -4709,7 +5393,7 @@ async function getDaemonStatus(options = {}) {
   }
   if (state && !isProcessAlive(state.pid)) {
     try {
-      fs5.unlinkSync(stateFile);
+      fs6.unlinkSync(stateFile);
     } catch {
     }
   }
@@ -4727,26 +5411,26 @@ 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 count = options.lines || 40;
   let content = "";
   try {
-    const stats = fs5.statSync(logFile);
+    const stats = fs6.statSync(logFile);
     const maxReadBytes = Math.min(stats.size, Math.max(256 * 1024, count * 2048));
     if (stats.size <= maxReadBytes) {
-      content = fs5.readFileSync(logFile, "utf-8");
+      content = fs6.readFileSync(logFile, "utf-8");
     } else {
-      const fd = fs5.openSync(logFile, "r");
+      const fd = fs6.openSync(logFile, "r");
       const buffer = Buffer.alloc(maxReadBytes);
-      fs5.readSync(fd, buffer, 0, maxReadBytes, stats.size - maxReadBytes);
-      fs5.closeSync(fd);
+      fs6.readSync(fd, buffer, 0, maxReadBytes, stats.size - maxReadBytes);
+      fs6.closeSync(fd);
       content = buffer.toString("utf-8");
     }
   } catch {
-    content = fs5.readFileSync(logFile, "utf-8");
+    content = fs6.readFileSync(logFile, "utf-8");
   }
   const allLines = content.split(/\r?\n/);
   const sanitizedLines = allLines.slice(-count).map((line) => {
@@ -4931,7 +5615,11 @@ var HISTORIC_SKILL_HASHES = [
   "8611116c276fdfb598b965c716b251ce7c77c7f7",
   "05f129fb6e06a18df00215af105567abcbf0bc67",
   "5d330ecf8fc96f383946e0351adb60378afa70f0",
-  "23716c9db561e52e5115dc364fe154d3a7bc1e23"
+  "23716c9db561e52e5115dc364fe154d3a7bc1e23",
+  "75d50d5f9cf9348cca9d9b2466e04cf7992ef17e",
+  "d0bd99ea93d9c65245b3be51188d4bc153024092",
+  "e5d4fe4f2ae0bd464bad877ea1e5ab63cef747fa",
+  "d25597e8c2c26cdc5873e5dbf02335032db07580"
 ];
 var ESEDRE_SKILL_TEMPLATE = `---
 name: esedre
@@ -4940,7 +5628,7 @@ description: Tooling and workflow reference for interacting with the Esedre deve
 
 # Esedre Planning & Roadmap Workflow
 
-Esedre is the developer ticketing and LLM coding partner coordination platform. The engine codebase resides in the standalone repository \`aellinsar/esedre\` (\`../esedre\`), and operates on decoupled ticket repositories (such as \`aellinsar/esedre-data\` configured in \`.esedre/esedre.json\`). Interact with tickets via in-repo shell wrappers in \`.esedre/\` (\`.esedre/ese\`), or the global \`ese\` CLI.
+Esedre is the developer ticketing and LLM coding partner coordination platform. The engine codebase resides in the standalone repository \`aellinsar/esedre\` (\`../esedre\`), and operates on decoupled ticket repositories (such as \`aellinsar/esedre-data\` configured in \`~/.esedre/config.json\` or \`.esedre/esedre.json\`). Interact with tickets via in-repo shell wrappers in \`.esedre/\` (\`.esedre/ese\` on POSIX/macOS/Linux/Git Bash, or \`.\\.esedre\\ese.cmd\` on Windows PowerShell/CMD), or the global \`ese\` CLI.
 
 ## 0. Authoritative Ingress Hierarchy & Zero-Latency Context (\`.esedre/snapshot.json\`)
 
@@ -4949,38 +5637,49 @@ All ticket discovery, inspection, and state management strictly follow this posi
 1. **Step 1 (Default for Read-Only Inspection) - Local Snapshot Projection**:
    Always read \`.esedre/snapshot.json\` in the workspace root first. It provides an immediate, zero-latency local projection containing all active and completed tickets, summaries, implementation plans, revision numbers, completion dates (\`completedAt\`), and staleness metrics (\`daysSinceUpdate\`).
 2. **Step 2 (Dynamic Queries & State Mutations) - Esedre MCP Tools**:
-   Use first-class MCP tools when active in the session (\`esedre_list_tickets\`, \`esedre_get_ticket\`, \`esedre_get_plan\`, \`esedre_save_plan\`, \`esedre_update_ticket\`, \`esedre_add_comment\`).
+   Use first-class MCP tools when active in the session (\`esedre_list_tickets\`, \`esedre_get_ticket\`, \`esedre_get_plan\`, \`esedre_save_plan\`, \`esedre_update_ticket\`, \`esedre_claim_ticket\`, \`esedre_renew_lease\`, \`esedre_release_ticket\`, \`esedre_list_leases\`, \`esedre_add_comment\`).
 3. **Step 3 (Terminal & Script Fallback) - In-Repo CLI Wrapper**:
-   Use \`.esedre/ese\` (\`.esedre/ese get\`, \`.esedre/ese plan\`, \`.esedre/ese update\`, \`.esedre/ese snapshot\`, \`.esedre/ese refresh\`).
+   - **POSIX (macOS, Linux, Git Bash, WSL)**: \`.esedre/ese <command>\` (e.g. \`.esedre/ese get\`, \`.esedre/ese plan\`, \`.esedre/ese update\`, \`.esedre/ese lease\`, \`.esedre/ese snapshot\`).
+   - **Windows (PowerShell / CMD)**: \`.\\.esedre\\ese.cmd <command>\` or \`.\\.esedre\\ese.ps1 <command>\` (do not invoke the extensionless POSIX script \`.esedre/ese\` directly in PowerShell or \`cmd.exe\`, as Windows will fail or prompt to select an application to open the file).
 4. **Storage Boundary**:
    Backing ticket hubs (such as \`esedre-data\`) represent data storage managed by the engine. All agent interactions with roadmap tickets flow through the snapshot projection, MCP tools, or CLI wrappers.
 
 ## 1. Model Context Protocol (MCP) Tools
 
-When Esedre MCP is active in your agent session (\`.agents/mcp_config.json\`), use these tools directly:
+When Esedre MCP is active in your agent session (\`.agents/mcp.json\` or \`.agents/mcp_config.json\`), use these tools directly:
 
 | Tool | Purpose | Key Arguments |
 |---|---|---|
-| \`esedre_list_tickets\` | List roadmap tickets with filters | \`project\` (e.g. \`Profe\`, \`Esedre\`, \`Alce\`), \`status\`, \`type\`, \`search\` |
-| \`esedre_get_ticket\` | Full specification, summary, comments, revision & sha1 | \`ticketId\` (numeric e.g. \`96\` or compound e.g. \`Profe-96\`) |
+| \`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, links, lease, 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_create_ticket\` | Mint a new ticket with auto sequential ID | \`title\` (max 48 chars), \`type\`, \`project\`, \`priority\`, \`milestone\`, \`effort\`, \`summary\`, \`detail\` |
+| \`esedre_update_ticket\` | Update ticket attributes with OCC | \`ticketId\`, \`status\`, \`type\`, \`priority\`, \`milestone\`, \`title\`, \`detail\`, \`detailMarkdown\`, \`complexity\`, \`effort\`, \`inDevelopment\`, \`featureFlag\`, \`lastHash\` |
+| \`esedre_claim_ticket\` | Claim an ephemeral TTL lease on a ticket (\`In Development\`) | \`ticketId\`, \`holder\`/\`workerId\`, \`agentType\`/\`system\`, \`ttlMinutes\`, \`branch\`, \`force\` |
+| \`esedre_renew_lease\` | Extend an active ticket lease TTL | \`ticketId\`, \`holder\`/\`workerId\`, \`system\`, \`ttlMinutes\` |
+| \`esedre_release_ticket\` | Release a ticket lease and optionally transition status | \`ticketId\`, \`holder\`/\`workerId\`, \`system\`, \`finalStatus\`, \`notes\`, \`force\` |
+| \`esedre_list_leases\` | List all active unexpired ticket leases | \`project\` |
+| \`esedre_link_ticket\` | Establish bi-directional ticket relationship | \`sourceTicketId\`, \`relation\` (\`relates-to\` \\| \`blocks\` \\| \`parent-of\` \\| \`duplicates\`), \`targetTicketId\`, \`author\` |
+| \`esedre_unlink_ticket\` | Remove bi-directional ticket relationship | \`sourceTicketId\`, \`targetTicketId\`, \`relation\` |
+| \`esedre_list_milestones\` | List project milestones and deliverables progress | \`project\` |
+| \`esedre_get_milestone\` | Get milestone specs, umbrella flag, and member tickets | \`milestoneId\` (numeric or title), \`project\` |
+| \`esedre_create_milestone\` | Create a project milestone with optional umbrella flag | \`title\`, \`project\`, \`featureFlag\`, \`status\`, \`targetDate\`, \`description\` |
+| \`esedre_update_milestone\` | Update milestone status, umbrella flag, or title | \`milestoneId\`, \`project\`, \`title\`, \`featureFlag\`, \`status\`, \`targetDate\`, \`description\` |
+| \`esedre_add_comment\` | Append developer or agent comment | \`ticketId\`, \`text\`, \`file\`, \`author\` |
 
 ## 2. Core CLI Commands (Fallback via \`run_command\`)
 
-Both \`esedre\` and \`ese\` work interchangeably:
+Both \`esedre\` and \`ese\` work interchangeably. On POSIX shells use \`.esedre/ese <command>\`; on Windows PowerShell or CMD use \`.\\.esedre\\ese.cmd <command>\` (or \`.\\.esedre\\ese.ps1 <command>\`):
 
 ### List Tickets
 \`\`\`bash
-.esedre/ese list [-p|--project <code|all>] [-s|--status <status>] [-t|--type <type>] [-q|--search <q>] [--json]
+.esedre/ese list [-p|--project <code|all>] [-s|--status <status>] [-t|--type <type>] [-P|--priority <priority>] [-m|--milestone <name>] [--blocked] [--linked-to <ticketKey>] [-q|--search <q>] [--json]
 \`\`\`
 
 ### Read Ticket Details
 \`\`\`bash
-.esedre/ese get <ticketId> [--json]
+.esedre/ese get <ticketId...> [--json]
 \`\`\`
 
 ### Read or Update Implementation Plans
@@ -4992,22 +5691,61 @@ Both \`esedre\` and \`ese\` work interchangeably:
 
 ### Create a Ticket
 \`\`\`bash
-.esedre/ese create --title "..." [-p|--project <code>] [-t|--type Feature] [--complexity Medium] [--effort "2.0 - 4.0 hours"] [--detail "<md>"] [--file <path>] [--json]
+.esedre/ese create --title "..." [-p|--project <code>] [-t|--type Feature] [-P|--priority High] [-m|--milestone <name>] [--complexity Medium] [--effort "2.0 - 4.0 hours"] [--detail "<md>"] [--file <path>] [--json]
 \`\`\`
 
 ### Update Ticket Status & Attributes
 \`\`\`bash
 .esedre/ese update <ticketId> --status "In Development"
 .esedre/ese update <ticketId> --status "Completed"
-.esedre/ese update <ticketId> --type Feature --complexity Medium --effort "2.0 - 4.0 hours"
+.esedre/ese update <ticketId> --type Feature -P High --complexity Medium --effort "2.0 - 4.0 hours"
+.esedre/ese update <ticketId> -P none           # Clears priority
+.esedre/ese update <ticketId> -m "Release 1.0"  # Links ticket to milestone (inherits umbrella feature flag)
+.esedre/ese update <ticketId> -m none           # Unlinks ticket from milestone
+.esedre/ese update <ticketId> --detail "<markdownContent>"  # Updates specification markdown
+.esedre/ese update <ticketId> --file <detailFilePath>       # Overwrites specification from file
+\`\`\`
+
+### Ticket Specification (\`detail.md\`) Sections
+When authoring or updating a ticket's \`detail.md\` (via \`--detail\`, \`--file\`, or \`esedre_update_ticket\`), the snapshot compiler and UI parser recognize the following canonical \`###\` headings:
+- \`### Summary\`: Concise overview of the problem or feature.
+- \`### Feature Breakdown\` (or aliases \`### Task Breakdown\`, \`### Fix Breakdown\`, \`### Implementation Breakdown\`): Numbered or bulleted deliverables and fix steps (indented sub-bullets are preserved under their parent item). Use \`### Fix Breakdown\` or \`### Task Breakdown\` naturally for \`Bug\` and \`Tools\` tickets.
+- \`### Technical Details\` (or \`### Technical Details & Architecture\`): Bold-keyed architectural notes (e.g. \`- **Architecture**: ...\`, \`- **Key Modules**: ...\`, \`- **Root Cause**: ...\`, \`- **Technical Detail**: ...\`).
+- \`### Open Questions\` (or \`### Open Questions & Decisions\`): Unresolved design questions (\`- **QuestionId**: Question text?\`), which populate \`openQuestions[]\` in \`.esedre/snapshot.json\`.
+
+### Ticket Leases (\`ese lease\`)
+\`\`\`bash
+.esedre/ese lease claim <ticketId> [--worker-id <id>] [--system <name>] [--ttl <minutes>] [--branch <branch>] [--force] [--json]
+.esedre/ese lease renew <ticketId> [--worker-id <id>] [--system <name>] [--ttl <minutes>] [--json]
+.esedre/ese lease release <ticketId> [--worker-id <id>] [--system <name>] [--status <Completed|Planned>] [--notes "..."] [--force] [--json]
+.esedre/ese lease list [-p|--project <code|all>] [--json]
+# Top-level aliases: ese claim, ese renew, ese release, ese leases
 \`\`\`
 
 ### 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"
 \`\`\`
 
+### Link or Unlink Tickets
+\`\`\`bash
+.esedre/ese link <sourceId> <relation> <targetId> [--author "..."]
+.esedre/ese unlink <sourceId> <targetId> [--relation <relation>]
+# Supported relations: relates-to, blocks, parent-of, duplicates
+# Inverse reciprocal links are automatically synchronized.
+\`\`\`
+
+### Manage Milestones & Umbrella Feature Flags
+\`\`\`bash
+.esedre/ese milestone list [-p|--project <code>] [--json]
+.esedre/ese milestone get <id|title> [-p|--project <code>] [--json]
+.esedre/ese milestone create --title "..." [-p|--project <code>] [--flag <flag>] [--status <status>] [--target-date <YYYY-MM-DD>] [--description "..."] [--json]
+.esedre/ese milestone update <id|title> [-p|--project <code>] [--title "..."] [--flag <flag|none>] [--status <status>] [--target-date <YYYY-MM-DD>] [--description "..."] [--json]
+.esedre/ese milestone delete <id|title> [-p|--project <code>] [--json]
+\`\`\`
+
 ### Regenerate Snapshot
 \`\`\`bash
 .esedre/ese snapshot
@@ -5050,7 +5788,10 @@ If the host application declares any or all of the 12 core design tokens on \`:r
 ## 4. Safety & Invariants
 - **Always use \`--json\`** for CLI programmatic inspection.
 - **Optimistic Concurrency**: Writes support \`--last-hash <hash>\` to prevent overwriting concurrent updates.
+- **Ticket Leases (\`ese lease\`)**: Claim a lease (\`ese lease claim <id>\` or \`esedre_claim_ticket\`) when starting active work so concurrent agent sessions or subagents do not collide on the same ticket, and release it (\`ese lease release <id>\`) upon completion.
 - **Universal Type Naming**: Always use \`type\` (\`Feature\`, \`Platform\`, \`Tools\`, \`Idea\`, \`Bug\`). The legacy name \`category\` is deprecated.
+- **Ticket Priority**: The \`priority\` field is optional (\`Critical\`, \`High\`, \`Medium\`, \`Low\`, or unset/null). Backwards compatible with legacy tickets lacking a priority field. To clear via CLI use \`-P none\` or \`--priority none\` (in code/MCP, pass \`null\` or \`'none'\`).
+- **Milestones & Umbrella Feature Flags**: Milestones group tickets into deliverables with completion metrics. Milestones can declare an optional umbrella feature flag which member tickets inherit automatically. Unlinking a ticket (\`-m none\`) removes inherited flags.
 - **Compound IDs for Multi-Project Portfolios**: In \`project=all\`, ticket IDs are \`\${projectCode}-\${id}\` (e.g. \`Profe-1\`, \`Esedre-1\`). DOM anchors strictly use \`feature-card-\${projectCode}-\${id}\`.
 - **Never delete tickets** directly via filesystem.
 - **Workspace Scoping**: An LLM coding partner operates strictly within the authorized project scope declared in the local repository configuration. Central repository linking and system-level configuration are managed separately; focus roadmap work, implementation plans, and verification notes on this project.
@@ -5059,9 +5800,38 @@ If the host application declares any or all of the 12 core design tokens on \`:r
   - **SEO Invariant**: These developer routes are private and MUST NEVER be exposed in \`sitemap.xml\`, \`robots.txt\`, \`llms.txt\`, or public navigation links.
   - The URL hash is preserved across hard page refreshes (F5) without falling back to \`#/chat\` or other views.
 `;
+var AGENT_RULE_MAX_BYTES = 24e3;
+function checkAgentRuleSizes(targetDir) {
+  const candidates = [
+    "AGENTS.md",
+    "GEMINI.md",
+    ".agents/AGENTS.md",
+    ".agents/GEMINI.md",
+    ".gemini/GEMINI.md"
+  ];
+  const warnings = [];
+  for (const rel of candidates) {
+    const fullPath = path7.join(targetDir, rel);
+    if (fs7.existsSync(fullPath)) {
+      try {
+        const stat = fs7.statSync(fullPath);
+        if (stat.isFile() && stat.size > AGENT_RULE_MAX_BYTES) {
+          warnings.push({
+            file: rel,
+            bytes: stat.size,
+            limitBytes: AGENT_RULE_MAX_BYTES,
+            message: `${rel} is ${stat.size.toLocaleString()} bytes (exceeds ${AGENT_RULE_MAX_BYTES.toLocaleString()}-byte agent rule context limit and will be truncated; extract detailed specs into .agents/skills/<name>/SKILL.md).`
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return warnings;
+}
 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 },
@@ -5071,62 +5841,117 @@ 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");
-  let configObj = { mcpServers: {} };
-  if (fs6.existsSync(mcpConfigPath)) {
-    try {
-      configObj = JSON.parse(fs6.readFileSync(mcpConfigPath, "utf-8"));
-      if (!configObj.mcpServers) configObj.mcpServers = {};
-    } catch {
-    }
-  }
-  if (process.platform === "win32") {
-    configObj.mcpServers.esedre = {
-      command: "cmd.exe",
-      args: ["/c", ".esedre\\esedre.cmd", "mcp"]
-    };
-  } else {
-    configObj.mcpServers.esedre = {
-      command: ".esedre/esedre",
-      args: ["mcp"]
-    };
+function setupGlobalAntigravityMcpConfig(options = {}) {
+  const geminiDir = options.geminiDir || process.env.ESEDRE_GEMINI_DIR || (process.env.VITEST ? null : path7.join(os5.homedir(), ".gemini"));
+  if (!geminiDir || !fs7.existsSync(geminiDir)) {
+    return false;
   }
   try {
-    fs6.writeFileSync(mcpConfigPath, JSON.stringify(configObj, null, 2) + "\n", "utf-8");
+    const configDir = path7.join(geminiDir, "config");
+    fs7.mkdirSync(configDir, { recursive: true });
+    const mcpConfigPath = path7.join(configDir, "mcp_config.json");
+    let configObj = { mcpServers: {} };
+    if (fs7.existsSync(mcpConfigPath)) {
+      try {
+        configObj = JSON.parse(fs7.readFileSync(mcpConfigPath, "utf-8"));
+        if (!configObj || typeof configObj !== "object") configObj = {};
+        if (!configObj.mcpServers || typeof configObj.mcpServers !== "object") {
+          configObj.mcpServers = {};
+        }
+      } catch {
+        configObj = { mcpServers: {} };
+      }
+    }
+    const existing = configObj.mcpServers.esedre;
+    const existingArgs = Array.isArray(existing?.args) ? existing.args.join(" ") : "";
+    const isBareRelativeWrapper = existing?.command === ".esedre/esedre" || existing?.command === ".esedre\\esedre.cmd" || existing?.command === "cmd.exe" && existingArgs.includes(".esedre\\esedre.cmd") && !existingArgs.toLowerCase().includes("if exist");
+    if (!existing || isBareRelativeWrapper) {
+      if (process.platform === "win32") {
+        const globalNpmEse = path7.join(
+          process.env.APPDATA || path7.join(os5.homedir(), "AppData", "Roaming"),
+          "npm",
+          "ese.cmd"
+        );
+        const fallbackCmd = fs7.existsSync(globalNpmEse) ? `call "${globalNpmEse}" mcp` : "call ese mcp";
+        configObj.mcpServers.esedre = {
+          command: "cmd.exe",
+          args: ["/c", `if exist .esedre\\esedre.cmd (call .esedre\\esedre.cmd mcp) else (${fallbackCmd})`]
+        };
+      } else {
+        configObj.mcpServers.esedre = {
+          command: "sh",
+          args: ["-c", "if [ -x .esedre/esedre ]; then exec .esedre/esedre mcp; else exec ese mcp; fi"]
+        };
+      }
+      fs7.writeFileSync(mcpConfigPath, JSON.stringify(configObj, null, 2) + "\n", "utf-8");
+    }
     return true;
   } catch {
     return false;
   }
 }
+function setupMcpConfig(targetDir, options = {}) {
+  const agentsDir = path7.join(targetDir, ".agents");
+  fs7.mkdirSync(agentsDir, { recursive: true });
+  const writeConfigFile = (fileName) => {
+    const mcpConfigPath = path7.join(agentsDir, fileName);
+    let configObj = { mcpServers: {} };
+    if (fs7.existsSync(mcpConfigPath)) {
+      try {
+        configObj = JSON.parse(fs7.readFileSync(mcpConfigPath, "utf-8"));
+        if (!configObj.mcpServers) configObj.mcpServers = {};
+      } catch {
+      }
+    }
+    if (process.platform === "win32") {
+      configObj.mcpServers.esedre = {
+        command: "cmd.exe",
+        args: ["/c", ".esedre\\esedre.cmd", "mcp"]
+      };
+    } else {
+      configObj.mcpServers.esedre = {
+        command: ".esedre/esedre",
+        args: ["mcp"]
+      };
+    }
+    try {
+      fs7.writeFileSync(mcpConfigPath, JSON.stringify(configObj, null, 2) + "\n", "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const okLegacy = writeConfigFile("mcp_config.json");
+  const okModern = writeConfigFile("mcp.json");
+  setupGlobalAntigravityMcpConfig(options);
+  return okLegacy && okModern;
+}
 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");
+  const hasBannedOrDeprecatedTerms = currentContent.includes("companion agent") || currentContent.includes("companion LLM") || currentContent.includes("tools/esedre.mjs") || currentContent.includes("# Esedre Planning & Roadmap Workflow") && (!currentContent.includes("ese.cmd") || !currentContent.includes("Fix Breakdown") || !currentContent.includes("<ticketId...>"));
   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 };
@@ -5140,8 +5965,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;
     }
   }
@@ -5205,10 +6030,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",
@@ -5239,7 +6064,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,
@@ -5254,15 +6079,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 {
     }
   }
@@ -5298,16 +6123,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(),
@@ -5319,14 +6144,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 {
       }
@@ -5345,6 +6170,7 @@ function configureWorkspace(targetDir, options = {}) {
   if (!globalStoreRes.ok) {
     console.warn(`\x1B[33m\u26A0\uFE0F Warning: Could not initialize global store at ${globalStoreRes.path}: ${globalStoreRes.error}\x1B[0m`);
   }
+  const ruleSizeWarnings = checkAgentRuleSizes(targetDir);
   return {
     esedreJsonCreatedOrUpdated: true,
     projectRegistered,
@@ -5359,7 +6185,8 @@ function configureWorkspace(targetDir, options = {}) {
     recommendedProxySnippet: proxyRes.recommendedProxySnippet,
     globalStoreStatus: globalStoreRes.ok ? "ready" : "warning",
     globalStorePath: globalStoreRes.path,
-    globalStoreError: globalStoreRes.error
+    globalStoreError: globalStoreRes.error,
+    ruleSizeWarnings
   };
 }
 var initWorkspace = configureWorkspace;
@@ -5369,33 +6196,33 @@ var ESEDRE_HUB_AGENTS_TEMPLATE = `# Agent Guidelines: esedre-data
 - **Backing Storage Repository**: \`esedre-data\` is a dedicated, decoupled data hub storing raw tickets, metadata manifests, and implementation plans managed by the Esedre engine.
 - **Authorized Ingress Channels**: Ticket discovery, read-only inspection, status updates, and plan authoring strictly ingress through the Esedre application layer in consuming project workspaces:
   1. **Local Workspace Snapshot**: Check the consuming workspace's \`.esedre/snapshot.json\` first for instant, zero-latency read access to ticket summaries, plans, and statuses.
-  2. **Esedre MCP Tools**: Use \`esedre_get_ticket\`, \`esedre_list_tickets\`, \`esedre_get_plan\`, \`esedre_save_plan\`, and \`esedre_update_ticket\`.
-  3. **Esedre CLI**: Execute \`.esedre/ese get <id>\`, \`.esedre/ese list\`, or \`.esedre/ese plan\` from within the relevant project workspace.
+  2. **Esedre MCP Tools**: Use \`esedre_get_ticket\`, \`esedre_list_tickets\`, \`esedre_get_plan\`, \`esedre_save_plan\`, \`esedre_create_ticket\`, \`esedre_update_ticket\`, \`esedre_claim_ticket\`, \`esedre_renew_lease\`, \`esedre_release_ticket\`, \`esedre_list_leases\`, and \`esedre_add_comment\`.
+  3. **Esedre CLI**: Execute \`.esedre/ese get <id>\`, \`.esedre/ese list\`, \`.esedre/ese plan\`, \`.esedre/ese create\`, \`.esedre/ese update\`, \`.esedre/ese lease\`, \`.esedre/ese comment\`, \`.esedre/ese snapshot\`, or \`.esedre/ese refresh\` from within the relevant project workspace.
 
 ## 2. Ingress Redirection Protocol
 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 {
@@ -5424,14 +6251,14 @@ function findOutdatedWrappers(currentWorkspaceRoot, globalConfig) {
   const outdated = [];
   const checkedDirs = /* @__PURE__ */ new Set();
   const checkDir = (dir, name) => {
-    const resolved = path6.resolve(expandHome(dir));
+    const resolved = path7.resolve(expandHome(dir));
     if (checkedDirs.has(resolved.toLowerCase())) return;
     checkedDirs.add(resolved.toLowerCase());
-    if (!fs6.existsSync(resolved)) return;
-    const cmdPath = path6.join(resolved, ".esedre", "esedre.cmd");
-    if (fs6.existsSync(cmdPath)) {
+    if (!fs7.existsSync(resolved)) return;
+    const cmdPath = path7.join(resolved, ".esedre", "esedre.cmd");
+    if (fs7.existsSync(cmdPath)) {
       try {
-        const content = fs6.readFileSync(cmdPath, "utf-8");
+        const content = fs7.readFileSync(cmdPath, "utf-8");
         if (isWrapperOutdated(content)) {
           outdated.push({ name, dir: resolved, wrapperPath: cmdPath });
         }
@@ -5440,7 +6267,7 @@ function findOutdatedWrappers(currentWorkspaceRoot, globalConfig) {
     }
   };
   if (currentWorkspaceRoot) {
-    checkDir(currentWorkspaceRoot, path6.basename(currentWorkspaceRoot));
+    checkDir(currentWorkspaceRoot, path7.basename(currentWorkspaceRoot));
   }
   if (globalConfig?.projects) {
     for (const [code, p] of Object.entries(globalConfig.projects)) {
@@ -5452,20 +6279,20 @@ function findOutdatedWrappers(currentWorkspaceRoot, globalConfig) {
 async function upgradeAllWorkspaces(options = {}) {
   const globalCfg = options.globalConfig !== void 0 ? options.globalConfig : readGlobalConfig();
   const workspaceMap = /* @__PURE__ */ new Map();
-  if (options.currentWorkspaceRoot && fs6.existsSync(options.currentWorkspaceRoot)) {
-    const hasEsedre = fs6.existsSync(path6.join(options.currentWorkspaceRoot, ".esedre")) || fs6.existsSync(path6.join(options.currentWorkspaceRoot, "esedre.json"));
+  if (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(
-        path6.resolve(options.currentWorkspaceRoot),
-        disc.config?.projectCode || path6.basename(options.currentWorkspaceRoot)
+        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 = path6.resolve(expandHome(p));
-      if (fs6.existsSync(resolved)) {
+      const resolved = path7.resolve(expandHome(p));
+      if (fs7.existsSync(resolved)) {
         if (!workspaceMap.has(resolved)) {
           workspaceMap.set(resolved, code);
         }
@@ -5516,15 +6343,15 @@ async function upgradeAllWorkspaces(options = {}) {
 }
 
 // src/server/gateway.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import http4 from "node:http";
-import path9 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",
@@ -5554,27 +6381,27 @@ function startUiServer(port, webDir) {
     if (!reqPath || reqPath === "/") {
       reqPath = "/index.html";
     }
-    const safePath = path7.normalize(reqPath).replace(/^(\.\.[/\\])+/, "");
-    let filePath = path7.join(webDir, safePath);
-    const resolvedFilePath = path7.resolve(filePath);
-    const resolvedWebDir = path7.resolve(webDir);
+    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 (!fs7.existsSync(filePath) || fs7.statSync(filePath).isDirectory()) {
-      filePath = path7.join(webDir, "index.html");
+    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) {
@@ -5596,8 +6423,8 @@ function startUiServer(port, webDir) {
 
 // src/server/apiServer.ts
 import http3 from "node:http";
-import fs8 from "node:fs";
-import path8 from "node:path";
+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) => {
@@ -5739,7 +6566,7 @@ function createApiHandler(storage, workspaceRoot) {
             const numKey = String(t.meta.id);
             const code = t.projectDescriptor?.code || t.meta.project || "Profe";
             const prefixedKey = `${code}-${t.meta.id}`;
-            const metaWithLinks = { ...t.meta, links: t.links || t.meta.links || [], isBlocked: t.isBlocked };
+            const metaWithLinks = { ...t.meta, links: t.links || t.meta.links || [], isBlocked: t.isBlocked, lease: t.lease || t.meta.lease || null };
             metasMap[prefixedKey] = metaWithLinks;
             if (!metasMap[numKey] || code.toUpperCase() === "PROF") {
               metasMap[numKey] = metaWithLinks;
@@ -5893,16 +6720,16 @@ function createApiHandler(storage, workspaceRoot) {
             return true;
           }
           const filePath = reqStorage.getAttachmentPath ? reqStorage.getAttachmentPath(ticketId, file) : null;
-          if (!filePath || !fs8.existsSync(filePath)) {
+          if (!filePath || !fs9.existsSync(filePath)) {
             sendJson(res, 404, { error: "Attachment not found." });
             return true;
           }
-          const stat = fs8.statSync(filePath);
+          const stat = fs9.statSync(filePath);
           if (!stat.isFile()) {
             sendJson(res, 404, { error: "Attachment not found." });
             return true;
           }
-          const ext = path8.extname(filePath).toLowerCase();
+          const ext = path9.extname(filePath).toLowerCase();
           const mimeTypes = {
             ".png": "image/png",
             ".jpg": "image/jpeg",
@@ -5920,7 +6747,7 @@ function createApiHandler(storage, workspaceRoot) {
             "Content-Length": stat.size,
             "Cache-Control": "public, max-age=86400"
           });
-          fs8.createReadStream(filePath).pipe(res);
+          fs9.createReadStream(filePath).pipe(res);
           return true;
         }
         if (pathname === "/api/planning/plan-history") {
@@ -5943,6 +6770,12 @@ function createApiHandler(storage, workspaceRoot) {
           sendJson(res, 200, { milestones });
           return true;
         }
+        if (pathname === "/api/planning/leases") {
+          const project = url.searchParams.get("project") || void 0;
+          const leases = await reqStorage.listLeases(project);
+          sendJson(res, 200, { leases });
+          return true;
+        }
       }
       if (req.method === "POST") {
         const body = await readJsonBody(req);
@@ -6175,6 +7008,61 @@ function createApiHandler(storage, workspaceRoot) {
           sendJson(res, 200, { success: true, source: result.source, target: result.target });
           return true;
         }
+        if (pathname === "/api/planning/leases/claim") {
+          invalidateApiCache();
+          const { ticketId, holder, agentType, hostname, sessionId, branch, worktree, ttlMinutes, force, project } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
+          const result = await reqStorage.claimTicket({
+            ticketId,
+            holder,
+            agentType,
+            hostname,
+            sessionId,
+            branch,
+            worktree,
+            ttlMinutes,
+            force: Boolean(force),
+            project
+          });
+          sendJson(res, 200, { success: true, ...result });
+          return true;
+        }
+        if (pathname === "/api/planning/leases/renew") {
+          invalidateApiCache();
+          const { ticketId, holder, ttlMinutes, force, project } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
+          const lease = await reqStorage.renewLease({
+            ticketId,
+            holder,
+            ttlMinutes,
+            force: Boolean(force),
+            project
+          });
+          sendJson(res, 200, { success: true, lease });
+          return true;
+        }
+        if (pathname === "/api/planning/leases/release") {
+          invalidateApiCache();
+          const { ticketId, holder, force, project } = body;
+          if (!ticketId) {
+            sendJson(res, 400, { error: "ticketId is required." });
+            return true;
+          }
+          const result = await reqStorage.releaseTicket({
+            ticketId,
+            holder,
+            force: Boolean(force),
+            project
+          });
+          sendJson(res, 200, { success: true, ...result });
+          return true;
+        }
       }
       sendJson(res, 404, { error: `Endpoint not found: ${pathname}` });
       return true;
@@ -6183,6 +7071,10 @@ function createApiHandler(storage, workspaceRoot) {
         sendJson(res, 403, { error: err.message });
         return true;
       }
+      if (err.name === "EsedreLeaseConflictError") {
+        sendJson(res, 409, { error: err.message, ticketKey: err.ticketKey, activeLease: err.activeLease });
+        return true;
+      }
       console.error("[Esedre API Error]:", err);
       sendJson(res, 500, { error: err.message });
       return true;
@@ -6211,35 +7103,35 @@ function startApiServer(port, storage, workspaceRoot) {
 
 // src/server/gateway.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path9.dirname(__filename2);
+var __dirname2 = path10.dirname(__filename2);
 function resolveWebDir(explicitWebDir, workspaceRoot) {
-  if (explicitWebDir && fs9.existsSync(path9.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)
-    path9.resolve(__dirname2, "web"),
+    path10.resolve(__dirname2, "web"),
     // 2. From workspace root: <workspaceRoot>/dist/web
-    workspaceRoot ? path9.resolve(workspaceRoot, "dist", "web") : "",
+    workspaceRoot ? path10.resolve(workspaceRoot, "dist", "web") : "",
     // 3. In-repo legacy subfolder: <workspaceRoot>/esedre/dist/web
-    workspaceRoot ? path9.resolve(workspaceRoot, "esedre", "dist", "web") : "",
+    workspaceRoot ? path10.resolve(workspaceRoot, "esedre", "dist", "web") : "",
     // 4. Sibling standalone repository from workspace root: <workspaceRoot>/../esedre/dist/web
-    workspaceRoot ? path9.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
+    workspaceRoot ? path10.resolve(workspaceRoot, "..", "esedre", "dist", "web") : "",
     // 5. Packaged layout inside dist/web
-    path9.resolve(__dirname2, "dist", "web"),
+    path10.resolve(__dirname2, "dist", "web"),
     // 6. Sibling standalone repository from __dirname: <__dirname>/../../esedre/dist/web
-    path9.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
+    path10.resolve(__dirname2, "..", "..", "esedre", "dist", "web"),
     // 7. Source tree layout: esedre/src/server/ -> esedre/dist/web
-    path9.resolve(__dirname2, "..", "..", "dist", "web"),
+    path10.resolve(__dirname2, "..", "..", "dist", "web"),
     // 8. Legacy layout from __dirname
-    path9.resolve(__dirname2, "..", "esedre", "dist", "web")
+    path10.resolve(__dirname2, "..", "esedre", "dist", "web")
   ].filter(Boolean);
   for (const candidate of candidates) {
-    if (fs9.existsSync(path9.join(candidate, "index.html"))) {
+    if (fs10.existsSync(path10.join(candidate, "index.html"))) {
       return candidate;
     }
   }
-  return candidates[0] || path9.resolve(__dirname2, "web");
+  return candidates[0] || path10.resolve(__dirname2, "web");
 }
 function proxyRequest(req, res, targetPort, rewritePath) {
   const targetPath = rewritePath ? rewritePath(req.url || "/") : req.url || "/";
@@ -6350,8 +7242,8 @@ ${colors.bold}ROADMAP COMMANDS (Pair Programming & LLM Agents):${colors.reset}
                \u2022 Status values: 'Planned', 'In Development', 'Completed', 'Rejected'
                \u2022 Type values:   'Feature', 'Platform', 'Tools', 'Idea', 'Bug'
 
-  ${colors.bold}get${colors.reset}         <id> [--json]
-               Inspect full ticket specification, feature breakdown, and comments.
+  ${colors.bold}get${colors.reset}         <id...> [--json]
+               Inspect full ticket specification, feature breakdown, and comments for one or more tickets.
 
   ${colors.bold}plan${colors.reset}        <id> [--file <path> | --set "<markdown>"] [--last-hash <sha1>] [--json]
                View or update implementation plan with optimistic concurrency control.
@@ -6362,7 +7254,7 @@ ${colors.bold}ROADMAP COMMANDS (Pair Programming & LLM Agents):${colors.reset}
   ${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]
@@ -6372,6 +7264,9 @@ ${colors.bold}ROADMAP COMMANDS (Pair Programming & LLM Agents):${colors.reset}
   ${colors.bold}unlink${colors.reset}      <sourceId> <targetId> [--json]
                Remove a link between two tickets and its reciprocal link.
 
+  ${colors.bold}lease${colors.reset}       [claim <id> | release <id> | renew <id> | list] [--by|--worker-id <holder>] [--ttl <mins>] [--branch <b>] [--status <stat>] [--notes "..."] [--force] [--json]
+               Coordinate multi-agent / multi-machine ticket ownership via TTL-backed advisory leases.
+
   ${colors.bold}snapshot, refresh${colors.reset} [--project <code>] [--json]
                Generate lean read-only projection snapshot (.esedre/snapshot.json) for zero-latency agent context.
 
@@ -6439,7 +7334,7 @@ ${colors.bold}OPTIONS:${colors.reset}
   --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 or update.
-  --file <path>        Path to markdown file for detail (create, update) or implementation plan (plan).
+  --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.
@@ -6512,7 +7407,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 (${path10.basename(warn.firstHub)} and ${path10.basename(warn.duplicateHub)}). Duplicate project codes across hubs are not supported; only '${path10.basename(warn.firstHub)}' is active.${colors.reset}`
+      `${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}`
     );
   }
 }
@@ -6531,6 +7426,7 @@ async function main() {
   }
   const rawArgs = process.argv.slice(2);
   const { command, positionals, flags } = parseArgs(rawArgs);
+  initLogger({ debug: Boolean(flags["debug"]) });
   try {
     writeGlobalVersion();
   } catch {
@@ -6555,7 +7451,7 @@ async function main() {
     switch (command) {
       case "init": {
         const rawTarget = positionals[0];
-        const targetDir = rawTarget ? path10.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);
@@ -6634,7 +7530,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
           console.error(`${colors.red}Error: ${nameVal.error}${colors.reset}`);
           process.exit(1);
         }
-        const isTargetHub = fs10.existsSync(path10.join(targetDir, "projects.json")) || fs10.existsSync(path10.join(targetDir, "projects")) && !fs10.existsSync(path10.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;
@@ -6705,7 +7601,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
         const viteConfigPath = findViteConfig(targetDir);
         if (viteConfigPath && setupProxy === void 0 && !isJson) {
           try {
-            const rawContent = fs10.readFileSync(viteConfigPath, "utf-8");
+            const rawContent = fs11.readFileSync(viteConfigPath, "utf-8");
             const alreadyConfigured = rawContent.includes("'/esedre'") || rawContent.includes('"/esedre"');
             if (!alreadyConfigured) {
               if (isYes) {
@@ -6715,7 +7611,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}${path10.basename(viteConfigPath)}${colors.reset}. Would you like to configure a reverse proxy for ${colors.bold}/esedre${colors.reset} targeting http://127.0.0.1:${port}? [Y/n] `
+                    `${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";
@@ -6731,10 +7627,10 @@ ${colors.bold}Next Steps:${colors.reset}`);
         let hubRelPath = void 0;
         if (rawHub) {
           const singleHub = Array.isArray(rawHub) ? rawHub[0] : rawHub;
-          const resolvedHub = path10.resolve(expandHome(singleHub));
-          if (fs10.existsSync(resolvedHub)) {
-            const rel = path10.relative(targetDir, resolvedHub).replace(/\\/g, "/");
-            const isSubdir = !rel.startsWith("..") && !path10.isAbsolute(rel);
+          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;
             }
@@ -6790,9 +7686,14 @@ ${colors.bold}Next Steps:${colors.reset}`);
           console.log(`  \u2022 In-repo wrappers: .esedre/esedre.cmd, .esedre/ese.cmd, .esedre/esedre, .esedre/ese`);
           console.log(`  \u2022 .gitignore: ${res.gitignoreUpdated ? "Added .esedre/snapshot.json" : "Already configured"}`);
           console.log(`  \u2022 Snapshot: Generated .esedre/snapshot.json (${snapshotTickets} tickets projected)`);
-          console.log(`  \u2022 MCP: ${res.mcpConfigured ? "Configured in .agents/mcp_config.json" : "Skipped"}`);
+          console.log(`  \u2022 MCP: ${res.mcpConfigured ? "Configured in .agents/mcp_config.json and .agents/mcp.json" : "Skipped"}`);
           console.log(`  \u2022 Skill: ${res.skillConfigured ? "Updated .agents/skills/esedre/SKILL.md" : `Retained (${res.skillStatus})`}`);
           console.log(`  \u2022 Central Config: Linked into ~/.esedre/config.json`);
+          if (res.ruleSizeWarnings && res.ruleSizeWarnings.length > 0) {
+            for (const rw of res.ruleSizeWarnings) {
+              console.log(`  \u2022 ${colors.yellow}\u26A0\uFE0F  Rule Size Warning: ${rw.message}${colors.reset}`);
+            }
+          }
           if (res.viteProxyStatus === "CONFIGURED") {
             console.log(`  \u2022 ${colors.green}Vite Proxy: Added /esedre proxy to ${res.viteConfigFile} targeting http://127.0.0.1:${effectivePort}${colors.reset}`);
           } else if (res.viteProxyStatus === "ALREADY_CONFIGURED") {
@@ -6908,7 +7809,7 @@ ${colors.bold}Next Steps:${colors.reset}`);
         }
         console.log(`
 ${colors.bold}${colors.cyan}Esedre Central Configuration${colors.reset}`);
-        console.log(`  \u2022 Config File:  ${configPath} ${fs10.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}`);
@@ -6974,11 +7875,16 @@ ${colors.bold}${colors.green}\u2714 Esedre multi-workspace upgrade completed acr
               } else if (w.upgrade.skillStatus === "CUSTOMIZED") {
                 console.log(`    - Preserved customized .agents/skills/esedre/SKILL.md`);
               }
+              if (w.upgrade.ruleSizeWarnings && w.upgrade.ruleSizeWarnings.length > 0) {
+                for (const rw of w.upgrade.ruleSizeWarnings) {
+                  console.log(`    - ${colors.yellow}\u26A0\uFE0F  ${rw.message}${colors.reset}`);
+                }
+              }
             }
           }
           return;
         }
-        const targetDir = positionals[0] ? path10.resolve(positionals[0]) : discovered.workspaceRoot;
+        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,
@@ -7005,6 +7911,11 @@ ${colors.bold}${colors.green}\u2714 Esedre multi-workspace upgrade completed acr
           } else if (res.skillStatus === "CUSTOMIZED") {
             console.log(`  \u2022 ${colors.yellow}Notice: .agents/skills/esedre/SKILL.md is customized; preserved user modifications (use --force to overwrite).${colors.reset}`);
           }
+          if (res.ruleSizeWarnings && res.ruleSizeWarnings.length > 0) {
+            for (const rw of res.ruleSizeWarnings) {
+              console.log(`  \u2022 ${colors.yellow}\u26A0\uFE0F  ${rw.message}${colors.reset}`);
+            }
+          }
         }
         return;
       }
@@ -7107,7 +8018,7 @@ ${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 && fs10.existsSync(status.logFile)) {
+            if (status.logFile && fs11.existsSync(status.logFile)) {
               console.log(`  \u2022 Recent Logs: ${status.logFile}`);
             }
           }
@@ -7238,7 +8149,9 @@ ${colors.yellow}Notice: ${outdatedWrappers.length} workspace(s) have legacy CMD
         const milestone = flags["milestone"] || flags["m"] || void 0;
         const isBlocked = flags["blocked"] ? true : void 0;
         const linkedTo = flags["linked-to"] || flags["linkedTo"] || void 0;
-        const tickets = await storage.listTickets({ project, status, type, category, priority, milestone, search, isBlocked, linkedTo });
+        const leased = flags["leased"] !== void 0 ? Boolean(flags["leased"]) : void 0;
+        const leasedBy = flags["leased-by"] || flags["leasedBy"] || void 0;
+        const tickets = await storage.listTickets({ project, status, type, category, priority, milestone, search, isBlocked, linkedTo, leased, leasedBy });
         if (isJson) {
           console.log(JSON.stringify(tickets.map((t) => ({
             id: t.meta.id,
@@ -7255,7 +8168,8 @@ ${colors.yellow}Notice: ${outdatedWrappers.length} workspace(s) have legacy CMD
             project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
             sha1: t.sha1 || t.meta.sha1,
             isBlocked: t.isBlocked,
-            links: t.links
+            links: t.links,
+            lease: t.lease || null
           })), null, 2));
         } else {
           if (tickets.length === 0) {
@@ -7278,22 +8192,30 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         return;
       }
       case "get": {
-        const idStr = positionals[0];
-        if (!idStr) {
+        if (positionals.length === 0) {
           console.error(`${colors.red}Error: Ticket ID is required (e.g. ese get 1 or ese get Profe-1)${colors.reset}`);
           process.exit(1);
         }
         const projectFlag = flags["project"];
-        const lookupKey = projectFlag && /^\d+$/.test(idStr) ? `${projectFlag}-${idStr}` : idStr;
-        const ticket = await storage.getTicket(lookupKey);
-        if (!ticket) {
-          console.error(`${colors.red}Error: Ticket #${lookupKey} not found.${colors.reset}`);
-          process.exit(1);
+        const tickets = [];
+        for (const idStr of positionals) {
+          const lookupKey = projectFlag && /^\d+$/.test(idStr) ? `${projectFlag}-${idStr}` : idStr;
+          const ticket = await storage.getTicket(lookupKey);
+          if (!ticket) {
+            console.error(`${colors.red}Error: Ticket #${lookupKey} not found.${colors.reset}`);
+            process.exit(1);
+          }
+          tickets.push(ticket);
         }
         if (isJson) {
-          console.log(JSON.stringify(ticket, null, 2));
+          console.log(JSON.stringify(tickets.length === 1 ? tickets[0] : tickets, null, 2));
         } else {
-          console.log(formatTicketDetail(ticket));
+          console.log(
+            tickets.map((t) => formatTicketDetail(t)).join(`
+${colors.dim}${"\u2500".repeat(60)}${colors.reset}
+
+`)
+          );
         }
         return;
       }
@@ -7312,11 +8234,11 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         if (setPlan || filePath) {
           let content = setPlan;
           if (filePath) {
-            if (!fs10.existsSync(filePath)) {
+            if (!fs11.existsSync(filePath)) {
               console.error(`${colors.red}Error: Plan file "${filePath}" not found.${colors.reset}`);
               process.exit(1);
             }
-            content = fs10.readFileSync(filePath, "utf-8");
+            content = fs11.readFileSync(filePath, "utf-8");
           }
           await storage.savePlan(id, content, lastHash);
           if (isJson) {
@@ -7388,8 +8310,8 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         const milestone = flags["milestone"] || flags["m"] || void 0;
         let detailMarkdown = detailArg;
         if (fileArg) {
-          const filePath = path10.resolve(fileArg);
-          if (!fs10.existsSync(filePath)) {
+          const filePath = path11.resolve(fileArg);
+          if (!fs11.existsSync(filePath)) {
             if (isJson) {
               console.error(JSON.stringify({ error: `Detail file "${fileArg}" not found` }));
             } else {
@@ -7397,7 +8319,7 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
             }
             process.exit(1);
           }
-          detailMarkdown = fs10.readFileSync(filePath, "utf-8");
+          detailMarkdown = fs11.readFileSync(filePath, "utf-8");
         }
         const created = await storage.createTicket({
           title,
@@ -7467,8 +8389,8 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         const fileArg = flags["file"];
         let detailMarkdown = detailArg ? normalizeDashesAndMojibake(detailArg) : void 0;
         if (fileArg) {
-          const filePath = path10.resolve(fileArg);
-          if (!fs10.existsSync(filePath)) {
+          const filePath = path11.resolve(fileArg);
+          if (!fs11.existsSync(filePath)) {
             if (isJson) {
               console.error(JSON.stringify({ error: `Detail file "${fileArg}" not found` }));
             } else {
@@ -7476,7 +8398,7 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
             }
             process.exit(1);
           }
-          detailMarkdown = normalizeDashesAndMojibake(fs10.readFileSync(filePath, "utf-8"));
+          detailMarkdown = normalizeDashesAndMojibake(fs11.readFileSync(filePath, "utf-8"));
         }
         if (detailMarkdown !== void 0) updates.detailMarkdown = detailMarkdown;
         const updated = await storage.updateTicket(lookupKey, updates, lastHash);
@@ -7634,10 +8556,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";
@@ -7701,6 +8643,129 @@ ${colors.bold}Tickets:${colors.reset}`);
         }
         return;
       }
+      case "claim":
+      case "release":
+      case "renew":
+      case "leases":
+      case "lease": {
+        const isTopLevelAlias = command === "claim" || command === "release" || command === "renew" || command === "leases";
+        const subAction = isTopLevelAlias ? command === "leases" ? "list" : command : positionals[0]?.toLowerCase() || "list";
+        const targetArg = isTopLevelAlias ? positionals[0] : positionals[1];
+        const project = flags["project"] || discovered.config?.projectCode;
+        const holder = flags["by"] || flags["holder"] || flags["worker-id"] || flags["workerId"] || flags["author"] || void 0;
+        const agentType = flags["agent"] || flags["agent-type"] || flags["system"] || void 0;
+        const sessionId = flags["session"] || flags["session-id"] || void 0;
+        const branch = flags["branch"] || void 0;
+        const ttlRaw = flags["ttl"] !== void 0 ? Number(flags["ttl"]) : void 0;
+        const isForce = Boolean(flags["force"] || flags["f"]);
+        if (subAction === "list" || subAction === "ls") {
+          const filterProject = flags["all"] || flags["a"] || flags["project"] === "all" ? "all" : project;
+          const leases = await storage.listLeases(filterProject);
+          if (isJson) {
+            console.log(JSON.stringify({ total: leases.length, leases }, null, 2));
+          } else {
+            console.log(formatLeaseListTable(leases));
+            if (leases.length > 0) {
+              console.log(`
+${colors.dim}Total: ${leases.length} active lease(s)${colors.reset}`);
+            }
+          }
+          return;
+        }
+        if (subAction === "claim") {
+          if (!targetArg) {
+            console.error(`${colors.red}Error: Ticket ID is required (e.g. ese lease claim 69 --by "agent-1")${colors.reset}`);
+            process.exit(1);
+          }
+          const identity = resolveWorkerIdentity({
+            holder,
+            agentType,
+            sessionId,
+            branch,
+            worktree: discovered.workspaceRoot,
+            configDefaultAuthor: discovered.config?.defaultAuthor
+          });
+          const res = await storage.claimTicket({
+            ticketId: targetArg,
+            holder: identity.holder,
+            agentType: identity.agentType,
+            hostname: identity.hostname,
+            sessionId: identity.sessionId,
+            branch: identity.branch,
+            worktree: identity.worktree,
+            ttlMinutes: ttlRaw,
+            force: isForce,
+            project
+          });
+          if (isJson) {
+            console.log(JSON.stringify(res, null, 2));
+          } else {
+            const actionLabel = res.overridden ? "Overrode & claimed" : res.renewed ? "Renewed lease on" : "Claimed lease on";
+            console.log(
+              `${colors.green}\u2714 ${actionLabel} Ticket ${res.lease.ticketKey}${colors.reset} for ${colors.bold}${res.lease.holder}${colors.reset}${res.lease.hostname ? ` on ${res.lease.hostname}` : ""} (TTL: ${res.lease.ttlMinutes}m, expires ${res.lease.expiresAt})`
+            );
+          }
+          return;
+        }
+        if (subAction === "renew" || subAction === "heartbeat") {
+          if (!targetArg) {
+            console.error(`${colors.red}Error: Ticket ID is required (e.g. ese lease renew 69)${colors.reset}`);
+            process.exit(1);
+          }
+          const lease = await storage.renewLease({
+            ticketId: targetArg,
+            holder,
+            ttlMinutes: ttlRaw,
+            force: isForce,
+            project
+          });
+          if (isJson) {
+            console.log(JSON.stringify({ success: true, lease }, null, 2));
+          } else {
+            console.log(
+              `${colors.green}\u2714 Renewed lease on Ticket ${lease.ticketKey}${colors.reset} for ${colors.bold}${lease.holder}${colors.reset} (expires ${lease.expiresAt})`
+            );
+          }
+          return;
+        }
+        if (subAction === "release" || subAction === "unlock") {
+          if (!targetArg) {
+            console.error(`${colors.red}Error: Ticket ID is required (e.g. ese lease release 69)${colors.reset}`);
+            process.exit(1);
+          }
+          const finalStatus = flags["status"] || void 0;
+          const notes = flags["notes"] || void 0;
+          const res = await storage.releaseTicket({
+            ticketId: targetArg,
+            holder,
+            force: isForce,
+            project
+          });
+          if (finalStatus) {
+            await storage.updateTicket(res.ticketKey || targetArg, { status: finalStatus });
+          }
+          if (notes) {
+            await storage.addComment(res.ticketKey || targetArg, {
+              author: holder || res.previousLease?.holder || discovered.config?.defaultAuthor || "Agent",
+              text: notes
+            });
+          }
+          if (isJson) {
+            console.log(JSON.stringify(res, null, 2));
+          } else {
+            if (res.released) {
+              console.log(
+                `${colors.green}\u2714 Released lease on Ticket ${res.ticketKey}${colors.reset}${res.previousLease ? ` (previously held by ${res.previousLease.holder})` : ""}${finalStatus ? ` -> ${finalStatus}` : ""}`
+              );
+            } else {
+              console.log(`${colors.dim}Ticket ${res.ticketKey} had no active lease.${colors.reset}`);
+            }
+          }
+          return;
+        }
+        console.error(`${colors.red}Error: Unknown lease action "${subAction}". Valid actions: claim, renew, release, list${colors.reset}`);
+        process.exit(1);
+      }
       default: {
         console.error(`${colors.red}Error: Unknown command "${command}"${colors.reset}`);
         printHelp();
@@ -7713,6 +8778,14 @@ ${colors.bold}Tickets:${colors.reset}`);
       console.error(`${colors.dim}Use --force to override if you are certain.${colors.reset}`);
       process.exit(1);
     }
+    if (err instanceof EsedreLeaseConflictError || err.name === "EsedreLeaseConflictError") {
+      if (isJson) {
+        console.error(JSON.stringify({ error: err.message, ticketKey: err.ticketKey, activeLease: err.activeLease }, null, 2));
+      } else {
+        console.error(`${colors.red}${err.message}${colors.reset}`);
+      }
+      process.exit(1);
+    }
     if (err instanceof EsedreAuthorizationError || err.name === "EsedreAuthorizationError") {
       console.error(`${colors.red}Access Denied: ${err.message}${colors.reset}`);
       process.exit(1);