yatt-md 0.1.0

package/dist/cli/serve.js

@@ -0,0 +1,3187 @@
+#!/usr/bin/env node
+
+// cli/serve.ts
+import * as http from "node:http";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFile } from "node:child_process";
+
+// src/lexer.ts
+var HEADER_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "owner",
+  "start",
+  "schedule",
+  "timezone",
+  "week-start"
+]);
+function tokenize(source) {
+  const lines = source.split(/\r?\n/);
+  const tokens = [];
+  let headerMode = true;
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (trimmed === "") {
+      tokens.push({ type: "blank", raw, line: lineNum });
+      continue;
+    }
+    if (trimmed.startsWith("//")) {
+      tokens.push({ type: "comment", raw, line: lineNum, content: trimmed.slice(2).trim() });
+      continue;
+    }
+    if (trimmed.startsWith("##")) {
+      headerMode = false;
+      tokens.push({ type: "section", raw, line: lineNum, level: 2, content: trimmed.slice(2).trim() });
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      headerMode = false;
+      tokens.push({ type: "section", raw, line: lineNum, level: 1, content: trimmed.slice(1).trim() });
+      continue;
+    }
+    if (/^parallel\s*:/i.test(trimmed)) {
+      headerMode = false;
+      const rest = trimmed.replace(/^parallel\s*:\s*/i, "");
+      tokens.push({ type: "parallel-open", raw, line: lineNum, content: rest });
+      continue;
+    }
+    if (/^end\s*:/i.test(trimmed)) {
+      headerMode = false;
+      const rest = trimmed.replace(/^end\s*:\s*/i, "");
+      tokens.push({ type: "parallel-close", raw, line: lineNum, content: rest });
+      continue;
+    }
+    if (trimmed.startsWith(">>")) {
+      headerMode = false;
+      tokens.push({ type: "milestone", raw, line: lineNum, content: trimmed.slice(2).trim() });
+      continue;
+    }
+    if (trimmed.startsWith("...")) {
+      headerMode = false;
+      tokens.push({ type: "subtask", raw, line: lineNum, depth: 3, content: trimmed.slice(3).trim() });
+      continue;
+    }
+    if (trimmed.startsWith("..") && !trimmed.startsWith("...")) {
+      headerMode = false;
+      tokens.push({ type: "subtask", raw, line: lineNum, depth: 2, content: trimmed.slice(2).trim() });
+      continue;
+    }
+    if (trimmed.startsWith(".") && !trimmed.startsWith("..")) {
+      headerMode = false;
+      tokens.push({ type: "subtask", raw, line: lineNum, depth: 1, content: trimmed.slice(1).trim() });
+      continue;
+    }
+    if (trimmed.startsWith("[")) {
+      headerMode = false;
+      tokens.push({ type: "task", raw, line: lineNum, content: trimmed });
+      continue;
+    }
+    if (headerMode) {
+      const headerMatch = trimmed.match(/^([\w-]+)\s*:\s*(.*)$/);
+      if (headerMatch && HEADER_KEYS.has(headerMatch[1].toLowerCase())) {
+        tokens.push({
+          type: "header-field",
+          raw,
+          line: lineNum,
+          key: headerMatch[1].toLowerCase(),
+          value: headerMatch[2].trim()
+        });
+        continue;
+      }
+    }
+    headerMode = false;
+    let plainContent = trimmed;
+    const listMarkerMatch = trimmed.match(/^(?:[-*]\s+|\d+[.)]\s+)/);
+    if (listMarkerMatch) {
+      plainContent = trimmed.slice(listMarkerMatch[0].length);
+    }
+    tokens.push({ type: "task", raw, line: lineNum, content: plainContent });
+  }
+  return tokens;
+}
+
+// src/parser.ts
+var SIGIL_TO_STATUS = {
+  " ": "new",
+  "~": "active",
+  "x": "done",
+  "!": "blocked",
+  "?": "at-risk",
+  ">": "deferred",
+  "_": "cancelled",
+  "-": "cancelled",
+  "=": "review",
+  "o": "paused"
+};
+var WORD_TO_STATUS = {
+  new: "new",
+  active: "active",
+  done: "done",
+  blocked: "blocked",
+  "at-risk": "at-risk",
+  deferred: "deferred",
+  cancelled: "cancelled",
+  review: "review",
+  paused: "paused"
+};
+var RE_DURATION = /^(\d+(?:\.\d+)?)(h|bd|d|w|m|q)$/;
+var RE_PRIORITY = /^!(high|critical|low|normal)$/;
+var RE_PROGRESS = /^%(\d+)$/;
+var RE_ID = /^id:([\w-]+)$/;
+var RE_HASH_ID = /^#([\w-]+)$/;
+var RE_AFTER = /^after:([\w|,-]+)$/;
+var RE_MODIFIER = /^\+[\w-]+(:\S+)?$/;
+var RE_START_DATE = /^>(\d{4}-\d{2}-\d{2})$/;
+var RE_DUE_DATE = /^<(\d{4}-\d{2}-\d{2})$/;
+var RE_RECURRENCE = /^\*(daily|weekday|weekly|biweekly|monthly|quarterly|yearly)$/;
+var RE_EXTERNAL_REF = /^\$[\w-]+$/;
+var MODIFIER_KEYWORDS = /* @__PURE__ */ new Set([
+  "deadline",
+  "fixed",
+  "external",
+  "waiting",
+  "at-risk",
+  "blocked",
+  "critical",
+  "tentative",
+  "recurring",
+  "milestone",
+  "delayed",
+  "hard-block"
+]);
+function parseStatus(content) {
+  const wordMatch = content.match(/^\[([\w-]+)\]\s*/);
+  if (wordMatch) {
+    const word = wordMatch[1].toLowerCase();
+    if (WORD_TO_STATUS[word]) {
+      return { status: WORD_TO_STATUS[word], rest: content.slice(wordMatch[0].length) };
+    }
+  }
+  const sigilMatch = content.match(/^\[(.)\]\s*/);
+  if (sigilMatch) {
+    const sigil = sigilMatch[1];
+    if (SIGIL_TO_STATUS[sigil] !== void 0) {
+      return { status: SIGIL_TO_STATUS[sigil], rest: content.slice(sigilMatch[0].length) };
+    }
+  }
+  return null;
+}
+function parseFields(segments) {
+  const result = { assignees: [], tags: [], after: [], modifiers: [] };
+  for (const seg of segments) {
+    const s = seg.trim();
+    if (!s) continue;
+    const durMatch = s.match(RE_DURATION);
+    if (durMatch && !result.duration) {
+      result.duration = { value: parseFloat(durMatch[1]), unit: durMatch[2] };
+      continue;
+    }
+    const startMatch = s.match(RE_START_DATE);
+    if (startMatch) {
+      result.startDate = startMatch[1];
+      continue;
+    }
+    const dueMatch = s.match(RE_DUE_DATE);
+    if (dueMatch) {
+      result.dueDate = dueMatch[1];
+      continue;
+    }
+    const idMatch = s.match(RE_ID);
+    if (idMatch) {
+      result.id = idMatch[1];
+      continue;
+    }
+    const afterMatch = s.match(RE_AFTER);
+    if (afterMatch) {
+      const raw = afterMatch[1];
+      if (raw.includes("|")) {
+        result.after.push({ ids: raw.split("|").filter(Boolean), logic: "or" });
+      } else {
+        result.after.push({ ids: raw.split(",").filter(Boolean), logic: "and" });
+      }
+      continue;
+    }
+    const prioMatch = s.match(RE_PRIORITY);
+    if (prioMatch) {
+      result.priority = prioMatch[1];
+      continue;
+    }
+    const progressMatch = s.match(RE_PROGRESS);
+    if (progressMatch) {
+      result.progress = Math.min(100, Math.max(0, parseInt(progressMatch[1], 10)));
+      continue;
+    }
+    const recurMatch = s.match(RE_RECURRENCE);
+    if (recurMatch) {
+      result.recurrence = recurMatch[1];
+      continue;
+    }
+    const shiftMatch = s.match(/^(delayed|blocked)\s+(\S+)$/);
+    if (shiftMatch) {
+      result.modifiers.push(shiftMatch[1] + ":" + shiftMatch[2]);
+      continue;
+    }
+    if (RE_MODIFIER.test(s)) {
+      result.modifiers.push(s.slice(1));
+      continue;
+    }
+    const bareModMatch = s.match(/^([\w-]+)(:\S+)?$/);
+    if (bareModMatch && MODIFIER_KEYWORDS.has(bareModMatch[1])) {
+      result.modifiers.push(s);
+      continue;
+    }
+    if (RE_EXTERNAL_REF.test(s)) {
+      result.externalRef = s;
+      continue;
+    }
+    const assigneeMatches = s.match(/(@[\w-]+)/g);
+    if (assigneeMatches && s.replace(/(@[\w-]+)/g, "").trim() === "") {
+      result.assignees.push(...assigneeMatches.map((a) => a.slice(1)));
+      continue;
+    }
+    const hashIdMatch = s.match(RE_HASH_ID);
+    if (hashIdMatch) {
+      result.id = hashIdMatch[1];
+      continue;
+    }
+  }
+  return result;
+}
+function splitPipeFields(content) {
+  const raw = content.split("|");
+  const merged = [];
+  for (let i = 0; i < raw.length; i++) {
+    const seg = raw[i].trim();
+    if (merged.length > 0 && /^after:/.test(merged[merged.length - 1].trim()) && /^[\w-]+$/.test(seg)) {
+      merged[merged.length - 1] += "|" + seg;
+    } else {
+      merged.push(raw[i]);
+    }
+  }
+  return merged;
+}
+function parseNameAndFields(content) {
+  const parts = splitPipeFields(content);
+  const name = (parts[0] ?? "").trim();
+  const fields = parseFields(parts.slice(1));
+  return { name, fields };
+}
+function buildTask(content, line2, depth = 0) {
+  const statusResult = parseStatus(content);
+  const status = statusResult?.status ?? "new";
+  const rest = statusResult?.rest ?? content;
+  const { name, fields } = parseNameAndFields(rest);
+  const task = {
+    type: "task",
+    status,
+    name,
+    assignees: fields.assignees,
+    tags: fields.tags,
+    after: fields.after,
+    modifiers: fields.modifiers,
+    subtasks: [],
+    line: line2
+  };
+  if (fields.id) task.id = fields.id;
+  if (fields.priority) task.priority = fields.priority;
+  if (fields.progress !== void 0) task.progress = fields.progress;
+  if (fields.duration) task.duration = fields.duration;
+  if (fields.startDate) task.startDate = fields.startDate;
+  if (fields.dueDate) task.dueDate = fields.dueDate;
+  if (fields.recurrence) task.recurrence = fields.recurrence;
+  if (fields.externalRef) task.externalRef = fields.externalRef;
+  return task;
+}
+function buildMilestone(content, line2) {
+  const { name, fields } = parseNameAndFields(content);
+  const ms = {
+    type: "milestone",
+    name,
+    after: fields.after,
+    modifiers: fields.modifiers,
+    line: line2
+  };
+  if (fields.id) ms.id = fields.id;
+  if (fields.startDate) ms.date = fields.startDate;
+  if (fields.dueDate) ms.date = fields.dueDate;
+  return ms;
+}
+function parse(source) {
+  const tokens = tokenize(source);
+  const errors = [];
+  const header = {};
+  const items = [];
+  const idMap = /* @__PURE__ */ new Map();
+  function registerId(id, item, line2) {
+    if (idMap.has(id)) {
+      errors.push({ message: `Duplicate ID: "${id}"`, line: line2, severity: "error" });
+    } else {
+      idMap.set(id, item);
+    }
+  }
+  let i = 0;
+  while (i < tokens.length && tokens[i].type === "header-field") {
+    const tok = tokens[i++];
+    switch (tok.key) {
+      case "title":
+        header.title = tok.value;
+        break;
+      case "owner":
+        header.owner = tok.value;
+        break;
+      case "start":
+        header.start = tok.value;
+        break;
+      case "schedule":
+        if (tok.value === "business-days" || tok.value === "calendar-days") {
+          header.schedule = tok.value;
+        }
+        break;
+      case "timezone":
+        header.timezone = tok.value;
+        break;
+      case "week-start":
+        if (tok.value === "mon" || tok.value === "sun") header.weekStart = tok.value;
+        break;
+    }
+  }
+  const parallelStack = [];
+  function currentContainer() {
+    if (parallelStack.length > 0) {
+      return parallelStack[parallelStack.length - 1];
+    }
+    return { items };
+  }
+  const taskStack = [null, null, null, null];
+  function resetTaskStack() {
+    taskStack[0] = taskStack[1] = taskStack[2] = taskStack[3] = null;
+  }
+  while (i < tokens.length) {
+    const tok = tokens[i++];
+    if (tok.type === "blank" || tok.type === "header-field") continue;
+    if (tok.type === "comment") {
+      const comment = { type: "comment", text: tok.content ?? "", line: tok.line };
+      currentContainer().items.push(comment);
+      continue;
+    }
+    if (tok.type === "section") {
+      resetTaskStack();
+      const section = {
+        type: "section",
+        title: tok.content ?? "",
+        level: tok.level === 2 ? 2 : 1,
+        line: tok.line
+      };
+      currentContainer().items.push(section);
+      continue;
+    }
+    if (tok.type === "parallel-open") {
+      resetTaskStack();
+      const content = tok.content ?? "";
+      const pipeIdx = content.indexOf("|");
+      let blockName;
+      let blockFields;
+      if (pipeIdx !== -1) {
+        blockName = content.slice(0, pipeIdx).trim() || void 0;
+        blockFields = parseFields(content.slice(pipeIdx + 1).split("|"));
+      } else {
+        blockName = content.trim() || void 0;
+        blockFields = parseFields([]);
+      }
+      const block = {
+        type: "parallel",
+        name: blockName,
+        id: blockName ?? void 0,
+        after: blockFields.after,
+        items: [],
+        line: tok.line
+      };
+      if (block.id) registerId(block.id, block, tok.line);
+      currentContainer().items.push(block);
+      parallelStack.push(block);
+      continue;
+    }
+    if (tok.type === "parallel-close") {
+      resetTaskStack();
+      if (parallelStack.length === 0) {
+        errors.push({ message: "Unexpected end: without matching parallel:", line: tok.line, severity: "error" });
+      } else {
+        parallelStack.pop();
+      }
+      continue;
+    }
+    if (tok.type === "milestone") {
+      resetTaskStack();
+      const ms = buildMilestone(tok.content ?? "", tok.line);
+      if (ms.id) registerId(ms.id, ms, tok.line);
+      const descLines = [];
+      while (i < tokens.length && tokens[i].type === "comment") {
+        descLines.push(tokens[i].content ?? "");
+        i++;
+      }
+      if (descLines.length > 0) ms.description = descLines.join("\n");
+      currentContainer().items.push(ms);
+      continue;
+    }
+    if (tok.type === "task") {
+      const task = buildTask(tok.content ?? "", tok.line, 0);
+      if (task.id) registerId(task.id, task, tok.line);
+      const descLines = [];
+      while (i < tokens.length && tokens[i].type === "comment") {
+        descLines.push(tokens[i].content ?? "");
+        i++;
+      }
+      if (descLines.length > 0) task.description = descLines.join("\n");
+      currentContainer().items.push(task);
+      taskStack[0] = task;
+      taskStack[1] = taskStack[2] = taskStack[3] = null;
+      continue;
+    }
+    if (tok.type === "subtask") {
+      const depth = tok.depth ?? 1;
+      const task = buildTask(tok.content ?? "", tok.line, depth);
+      if (task.id) registerId(task.id, task, tok.line);
+      const descLines = [];
+      while (i < tokens.length && tokens[i].type === "comment") {
+        descLines.push(tokens[i].content ?? "");
+        i++;
+      }
+      if (descLines.length > 0) task.description = descLines.join("\n");
+      taskStack[depth] = task;
+      for (let d = depth + 1; d <= 3; d++) taskStack[d] = null;
+      let attached = false;
+      for (let pd = depth - 1; pd >= 0; pd--) {
+        if (taskStack[pd]) {
+          taskStack[pd].subtasks.push(task);
+          attached = true;
+          break;
+        }
+      }
+      if (!attached) {
+        currentContainer().items.push(task);
+      }
+      continue;
+    }
+  }
+  if (parallelStack.length > 0) {
+    errors.push({
+      message: `Unclosed parallel block: "${parallelStack[parallelStack.length - 1].name ?? "(anonymous)"}"`,
+      line: parallelStack[parallelStack.length - 1].line,
+      severity: "error"
+    });
+  }
+  const doc = { header, items, idMap };
+  function resolveItem(item) {
+    for (const dep of item.after) {
+      for (const id of dep.ids) {
+        if (!idMap.has(id)) {
+          errors.push({
+            message: `Unknown dependency ID: "${id}"`,
+            line: item.line,
+            severity: "error"
+          });
+        }
+      }
+    }
+    if (item.type === "task") {
+      for (const sub of item.subtasks) resolveItem(sub);
+    }
+  }
+  function resolveBlock(block) {
+    for (const dep of block.after) {
+      for (const id of dep.ids) {
+        if (!idMap.has(id)) {
+          errors.push({
+            message: `Unknown dependency ID: "${id}" in parallel block`,
+            line: block.line,
+            severity: "error"
+          });
+        }
+      }
+    }
+    for (const it of block.items) {
+      if (it.type === "task" || it.type === "milestone") resolveItem(it);
+      else if (it.type === "parallel") resolveBlock(it);
+    }
+  }
+  for (const item of items) {
+    if (item.type === "task" || item.type === "milestone") resolveItem(item);
+    else if (item.type === "parallel") resolveBlock(item);
+  }
+  return { doc, errors };
+}
+
+// src/validator.ts
+function validate(doc) {
+  const errors = [];
+  const allSchedulable = [];
+  function collectItems(items) {
+    for (const item of items) {
+      if (item.type === "task") {
+        allSchedulable.push(item);
+        collectItems(item.subtasks);
+      } else if (item.type === "milestone") {
+        allSchedulable.push(item);
+      } else if (item.type === "parallel") {
+        collectItems(item.items);
+      }
+    }
+  }
+  collectItems(doc.items);
+  for (const item of allSchedulable) {
+    for (const dep of item.after) {
+      for (const id of dep.ids) {
+        if (!doc.idMap.has(id)) {
+          errors.push({
+            message: `Reference to unknown ID "${id}"`,
+            line: item.line,
+            severity: "error"
+          });
+        }
+      }
+    }
+  }
+  for (const item of allSchedulable) {
+    if (item.type === "task") {
+      if (item.progress === 100 && item.status !== "done") {
+        errors.push({
+          message: `Task "${item.name}" has 100% progress but status is not "done"`,
+          line: item.line,
+          severity: "warning"
+        });
+      }
+      if (item.status === "done" && item.progress !== void 0 && item.progress < 100) {
+        errors.push({
+          message: `Task "${item.name}" has status "done" but progress is ${item.progress}%`,
+          line: item.line,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  for (const item of allSchedulable) {
+    if (item.type === "task") {
+      if ((item.status === "deferred" || item.status === "cancelled") && item.after.length > 0) {
+        errors.push({
+          message: `Task "${item.name}" is ${item.status} but has dependency constraints`,
+          line: item.line,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const [id] of doc.idMap) {
+    inDegree.set(id, 0);
+    dependents.set(id, []);
+  }
+  function addDepsForItem(item) {
+    if (!item.id) return;
+    for (const dep of item.after) {
+      for (const depId of dep.ids) {
+        if (!doc.idMap.has(depId)) continue;
+        dependents.get(depId)?.push(item.id);
+        inDegree.set(item.id, (inDegree.get(item.id) ?? 0) + 1);
+      }
+    }
+  }
+  for (const item of allSchedulable) {
+    addDepsForItem(item);
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) queue.push(id);
+  }
+  let processed = 0;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    processed++;
+    for (const dependent of dependents.get(current) ?? []) {
+      const newDeg = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDeg);
+      if (newDeg === 0) queue.push(dependent);
+    }
+  }
+  if (processed < inDegree.size) {
+    const cycleIds = [...inDegree.entries()].filter(([, deg]) => deg > 0).map(([id]) => id);
+    errors.push({
+      message: `Dependency cycle detected among: ${cycleIds.join(", ")}`,
+      line: 0,
+      severity: "error"
+    });
+  }
+  return errors;
+}
+
+// src/scheduler.ts
+function parseModifierDuration(modifier) {
+  const match = modifier.match(/^[\w-]+:(\d+(?:\.\d+)?)(h|bd|d|w|m|q)$/);
+  if (!match) return null;
+  return { value: parseFloat(match[1]), unit: match[2] };
+}
+function addDays(date, days) {
+  const d = new Date(date);
+  d.setUTCDate(d.getUTCDate() + Math.round(days));
+  return d;
+}
+function isWeekend(date, weekStart = "mon") {
+  const dow = date.getUTCDay();
+  if (weekStart === "sun") {
+    return dow === 5 || dow === 6;
+  }
+  return dow === 0 || dow === 6;
+}
+function addBusinessDays(date, days, weekStart = "mon") {
+  let d = new Date(date);
+  let remaining = Math.round(days);
+  const sign = remaining >= 0 ? 1 : -1;
+  remaining = Math.abs(remaining);
+  while (remaining > 0) {
+    d = addDays(d, sign);
+    if (!isWeekend(d, weekStart)) {
+      remaining--;
+    }
+  }
+  return d;
+}
+function addDuration(start, duration, useBusinessDays, weekStart = "mon") {
+  const { value, unit } = duration;
+  switch (unit) {
+    case "h": {
+      const ms = value * 60 * 60 * 1e3;
+      return new Date(start.getTime() + ms);
+    }
+    case "d":
+      return addDays(start, value);
+    case "bd":
+      return addBusinessDays(start, value, weekStart);
+    case "w":
+      return addDays(start, value * 7);
+    case "m": {
+      const d = new Date(start);
+      d.setUTCMonth(d.getUTCMonth() + value);
+      return d;
+    }
+    case "q": {
+      const d = new Date(start);
+      d.setUTCMonth(d.getUTCMonth() + value * 3);
+      return d;
+    }
+    default:
+      return addDays(start, value);
+  }
+}
+function parseDate(s) {
+  return /* @__PURE__ */ new Date(s + "T00:00:00Z");
+}
+function maxDate(a, b) {
+  return a.getTime() >= b.getTime() ? a : b;
+}
+function minDate(a, b) {
+  return a.getTime() <= b.getTime() ? a : b;
+}
+function resolvedEnd(id, ctx) {
+  const item = ctx.idMap.get(id);
+  if (!item) return void 0;
+  if (item.type === "task") return item.computedEnd;
+  if (item.type === "milestone") return item.computedDate;
+  if (item.type === "parallel") return item.computedEnd;
+  return void 0;
+}
+function computeStartFromDeps(after, ctx) {
+  if (after.length === 0) return void 0;
+  let result;
+  for (const dep of after) {
+    let depDate;
+    if (dep.logic === "and") {
+      for (const id of dep.ids) {
+        const end = resolvedEnd(id, ctx);
+        if (end) depDate = depDate ? maxDate(depDate, end) : end;
+      }
+    } else {
+      for (const id of dep.ids) {
+        const end = resolvedEnd(id, ctx);
+        if (end) depDate = depDate ? minDate(depDate, end) : end;
+      }
+    }
+    if (depDate) result = result ? maxDate(result, depDate) : depDate;
+  }
+  return result;
+}
+function scheduleTask(task, sequentialAnchor, ctx) {
+  const isFixed = task.modifiers.includes("fixed") && task.startDate;
+  let start;
+  if (isFixed && task.startDate) {
+    start = parseDate(task.startDate);
+  } else {
+    const depStart = computeStartFromDeps(task.after, ctx);
+    if (task.after.length > 0) {
+      start = depStart ?? sequentialAnchor;
+    } else {
+      start = sequentialAnchor;
+    }
+    if (task.startDate) {
+      const explicit = parseDate(task.startDate);
+      start = maxDate(start, explicit);
+    }
+  }
+  task.computedStart = start;
+  if (task.duration) {
+    const bd = task.duration.unit === "bd" || ctx.useBusinessDays;
+    task.computedEnd = addDuration(start, task.duration, bd, ctx.weekStart);
+  } else {
+    task.computedEnd = new Date(start);
+  }
+  const blockedMod = task.modifiers.find((m) => m.startsWith("blocked:"));
+  if (blockedMod) {
+    const blockDur = parseModifierDuration(blockedMod);
+    if (blockDur) {
+      task.plannedStart = new Date(task.computedStart);
+      task.plannedEnd = task.computedEnd ? new Date(task.computedEnd) : void 0;
+      const bd = blockDur.unit === "bd" || ctx.useBusinessDays;
+      task.computedStart = addDuration(task.computedStart, blockDur, bd, ctx.weekStart);
+      if (task.duration) {
+        const durBd = task.duration.unit === "bd" || ctx.useBusinessDays;
+        task.computedEnd = addDuration(task.computedStart, task.duration, durBd, ctx.weekStart);
+      } else {
+        task.computedEnd = new Date(task.computedStart);
+      }
+    }
+  }
+  const delayedMod = task.modifiers.find((m) => m.startsWith("delayed:"));
+  if (delayedMod) {
+    const delayDur = parseModifierDuration(delayedMod);
+    if (delayDur) {
+      task.delayStart = task.computedEnd ? new Date(task.computedEnd) : void 0;
+      if (!task.plannedStart) {
+        task.plannedStart = new Date(task.computedStart);
+        task.plannedEnd = task.computedEnd ? new Date(task.computedEnd) : void 0;
+      }
+      const bd = delayDur.unit === "bd" || ctx.useBusinessDays;
+      if (task.computedEnd) {
+        task.computedEnd = addDuration(task.computedEnd, delayDur, bd, ctx.weekStart);
+      }
+    }
+  }
+  let subAnchor = start;
+  for (const sub of task.subtasks) {
+    scheduleTask(sub, subAnchor, ctx);
+    if (sub.computedEnd && sub.status !== "deferred" && sub.status !== "cancelled") {
+      subAnchor = sub.computedEnd;
+    }
+  }
+  if (task.subtasks.length > 0) {
+    for (const sub of task.subtasks) {
+      if (sub.computedEnd) {
+        task.computedEnd = task.computedEnd ? maxDate(task.computedEnd, sub.computedEnd) : sub.computedEnd;
+      }
+    }
+  }
+}
+function scheduleMilestone(ms, sequentialAnchor, ctx) {
+  const depStart = computeStartFromDeps(ms.after, ctx);
+  let date;
+  if (ms.after.length > 0) {
+    date = depStart ?? sequentialAnchor;
+  } else {
+    date = sequentialAnchor;
+  }
+  if (ms.date) {
+    const explicit = parseDate(ms.date);
+    date = maxDate(date, explicit);
+  }
+  ms.computedDate = date;
+}
+function scheduleBlock(block, sequentialAnchor, ctx) {
+  const depStart = computeStartFromDeps(block.after, ctx);
+  const blockStart = depStart ? maxDate(depStart, sequentialAnchor) : sequentialAnchor;
+  block.computedStart = blockStart;
+  let innerAnchor = blockStart;
+  for (const item of block.items) {
+    if (item.type === "task") {
+      scheduleTask(item, innerAnchor, ctx);
+      if (item.computedEnd && item.status !== "deferred" && item.status !== "cancelled") {
+        innerAnchor = item.computedEnd;
+      }
+    } else if (item.type === "milestone") {
+      scheduleMilestone(item, innerAnchor, ctx);
+      if (item.computedDate) innerAnchor = item.computedDate;
+    } else if (item.type === "parallel") {
+      scheduleBlock(item, innerAnchor, ctx);
+    }
+  }
+  let blockEnd;
+  for (const item of block.items) {
+    let itemEnd;
+    if (item.type === "task") itemEnd = item.computedEnd;
+    else if (item.type === "milestone") itemEnd = item.computedDate;
+    else if (item.type === "parallel") itemEnd = item.computedEnd;
+    if (itemEnd) blockEnd = blockEnd ? maxDate(blockEnd, itemEnd) : itemEnd;
+  }
+  block.computedEnd = blockEnd ?? blockStart;
+}
+function schedule(doc) {
+  const projectStart = doc.header.start ? parseDate(doc.header.start) : new Date(Date.UTC((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth(), (/* @__PURE__ */ new Date()).getUTCDate()));
+  const useBusinessDays = doc.header.schedule === "business-days";
+  const weekStart = doc.header.weekStart ?? "mon";
+  const ctx = {
+    projectStart,
+    useBusinessDays,
+    weekStart,
+    idMap: doc.idMap
+  };
+  let sequentialAnchor = projectStart;
+  for (const item of doc.items) {
+    if (item.type === "task") {
+      scheduleTask(item, sequentialAnchor, ctx);
+      if (item.computedEnd && item.status !== "deferred" && item.status !== "cancelled") {
+        sequentialAnchor = item.computedEnd;
+      }
+    } else if (item.type === "milestone") {
+      scheduleMilestone(item, sequentialAnchor, ctx);
+      if (item.computedDate) sequentialAnchor = item.computedDate;
+    } else if (item.type === "parallel") {
+      scheduleBlock(item, sequentialAnchor, ctx);
+    }
+  }
+  return doc;
+}
+
+// src/renderer/gantt-svg.ts
+var STATUS_COLORS = {
+  new: "#93a8c4",
+  active: "#6a9fd8",
+  done: "#6aab85",
+  blocked: "#c97070",
+  "at-risk": "#c9a04a",
+  deferred: "#a892cc",
+  cancelled: "#8a96a6",
+  review: "#8e7ec4",
+  paused: "#7a90a6"
+};
+var STATUS_DARK = {
+  new: "#7a90a8",
+  active: "#5588c0",
+  done: "#56986e",
+  blocked: "#b85a5a",
+  "at-risk": "#b8902a",
+  deferred: "#9278b8",
+  cancelled: "#606878",
+  review: "#7868b0",
+  paused: "#607080"
+};
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function collectRows(items, depth, rows, inBlock, block) {
+  for (const item of items) {
+    if (item.type === "task") {
+      rows.push({ kind: "task", task: item, depth, inBlock, block });
+      if (item.subtasks.length > 0) {
+        collectRows(item.subtasks, depth + 1, rows, inBlock, block);
+      }
+    } else if (item.type === "milestone") {
+      rows.push({ kind: "milestone", milestone: item, depth, inBlock, block });
+    } else if (item.type === "parallel") {
+      const blockStartRow = rows.length;
+      rows.push({ kind: "parallel-header", block: item, depth, blockRowStart: blockStartRow });
+      collectRows(item.items, depth, rows, true, item);
+      if (rows.length > blockStartRow) {
+        rows[rows.length - 1].isLastInBlock = true;
+      }
+    }
+  }
+}
+function getDates(rows) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const row of rows) {
+    if (row.kind === "task" && row.task) {
+      if (row.task.computedStart) min = Math.min(min, row.task.computedStart.getTime());
+      if (row.task.computedEnd) max = Math.max(max, row.task.computedEnd.getTime());
+    }
+    if (row.kind === "milestone" && row.milestone?.computedDate) {
+      const t = row.milestone.computedDate.getTime();
+      min = Math.min(min, t);
+      max = Math.max(max, t);
+    }
+  }
+  if (!isFinite(min)) min = Date.now();
+  if (!isFinite(max)) max = min + 7 * 864e5;
+  const span = max - min;
+  return {
+    minDate: new Date(min - span * 0.02),
+    maxDate: new Date(max + span * 0.05)
+  };
+}
+function getGranularity(spanDays) {
+  if (spanDays < 30) return "day";
+  if (spanDays < 180) return "week";
+  if (spanDays < 365) return "month";
+  return "quarter";
+}
+function generateTicks(minD, maxD, granularity) {
+  const ticks = [];
+  const cur = new Date(minD);
+  if (granularity === "day") {
+    cur.setUTCHours(0, 0, 0, 0);
+    while (cur <= maxD) {
+      ticks.push(new Date(cur));
+      cur.setUTCDate(cur.getUTCDate() + 1);
+    }
+  } else if (granularity === "week") {
+    cur.setUTCHours(0, 0, 0, 0);
+    const dow = cur.getUTCDay();
+    const toMon = dow === 0 ? -6 : 1 - dow;
+    cur.setUTCDate(cur.getUTCDate() + toMon);
+    while (cur <= maxD) {
+      ticks.push(new Date(cur));
+      cur.setUTCDate(cur.getUTCDate() + 7);
+    }
+  } else if (granularity === "month") {
+    cur.setUTCDate(1);
+    cur.setUTCHours(0, 0, 0, 0);
+    while (cur <= maxD) {
+      ticks.push(new Date(cur));
+      cur.setUTCMonth(cur.getUTCMonth() + 1);
+    }
+  } else {
+    cur.setUTCDate(1);
+    cur.setUTCHours(0, 0, 0, 0);
+    const q = Math.floor(cur.getUTCMonth() / 3);
+    cur.setUTCMonth(q * 3);
+    while (cur <= maxD) {
+      ticks.push(new Date(cur));
+      cur.setUTCMonth(cur.getUTCMonth() + 3);
+    }
+  }
+  return ticks;
+}
+function formatTick(d, granularity) {
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  if (granularity === "day") {
+    return `${d.getUTCDate()} ${months[d.getUTCMonth()]}`;
+  }
+  if (granularity === "week") {
+    return `${months[d.getUTCMonth()]} ${d.getUTCDate()}`;
+  }
+  if (granularity === "month") {
+    return `${months[d.getUTCMonth()]} ${d.getUTCFullYear()}`;
+  }
+  const q = Math.floor(d.getUTCMonth() / 3) + 1;
+  return `Q${q} ${d.getUTCFullYear()}`;
+}
+function rect(x, y, w, h, attrs = {}) {
+  const attrStr = Object.entries(attrs).map(([k, v]) => `${k}="${v}"`).join(" ");
+  return `<rect x="${x}" y="${y}" width="${Math.max(0, w)}" height="${h}" ${attrStr}/>`;
+}
+function text(x, y, content, attrs = {}) {
+  const attrStr = Object.entries(attrs).map(([k, v]) => `${k}="${v}"`).join(" ");
+  return `<text x="${x}" y="${y}" ${attrStr}>${escapeXml(content)}</text>`;
+}
+function line(x1, y1, x2, y2, attrs = {}) {
+  const attrStr = Object.entries(attrs).map(([k, v]) => `${k}="${v}"`).join(" ");
+  return `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" ${attrStr}/>`;
+}
+function circle(cx, cy, r, attrs = {}) {
+  const attrStr = Object.entries(attrs).map(([k, v]) => `${k}="${v}"`).join(" ");
+  return `<circle cx="${cx}" cy="${cy}" r="${r}" ${attrStr}/>`;
+}
+function initials(name) {
+  return name.split(/[\s_-]/).slice(0, 2).map((w) => w[0]?.toUpperCase() ?? "").join("");
+}
+function renderGanttSVG(doc, options) {
+  const opts = {
+    width: options?.width ?? 1200,
+    rowHeight: options?.rowHeight ?? 28,
+    headerHeight: options?.headerHeight ?? 40,
+    padding: options?.padding ?? 16,
+    fontFamily: options?.fontFamily ?? "ui-sans-serif, system-ui, sans-serif",
+    theme: options?.theme ?? "light"
+  };
+  const isDark = opts.theme === "dark";
+  const bgColor = isDark ? "#0f172a" : "#ffffff";
+  const textColor = isDark ? "#e2e8f0" : "#1e293b";
+  const mutedColor = isDark ? "#64748b" : "#94a3b8";
+  const trackColor = isDark ? "#1e293b" : "#f1f5f9";
+  const borderColor = isDark ? "#334155" : "#e2e8f0";
+  const labelWidth = 200;
+  const chartLeft = opts.padding + labelWidth;
+  const chartWidth = opts.width - chartLeft - opts.padding;
+  const rows = [];
+  collectRows(doc.items, 0, rows, false);
+  const { minDate: minDate2, maxDate: maxDate2 } = getDates(rows);
+  const totalMs = maxDate2.getTime() - minDate2.getTime();
+  const spanDays = totalMs / 864e5;
+  function dateToX(d) {
+    const frac = (d.getTime() - minDate2.getTime()) / totalMs;
+    return chartLeft + frac * chartWidth;
+  }
+  const granularity = getGranularity(spanDays);
+  const ticks = generateTicks(minDate2, maxDate2, granularity);
+  const totalHeight = opts.headerHeight + rows.length * opts.rowHeight + opts.padding;
+  const parts = [];
+  parts.push(`<defs>
+  <clipPath id="chart-clip"><rect x="${chartLeft}" y="0" width="${chartWidth}" height="${totalHeight}"/></clipPath>
+</defs>`);
+  parts.push(rect(0, 0, opts.width, totalHeight, { fill: bgColor }));
+  if (doc.header.title) {
+    parts.push(text(opts.padding, opts.headerHeight / 2 + 5, doc.header.title, {
+      fill: textColor,
+      "font-size": "14",
+      "font-weight": "600",
+      "font-family": opts.fontFamily
+    }));
+  }
+  const axisY = opts.headerHeight - 1;
+  parts.push(line(chartLeft, axisY, chartLeft + chartWidth, axisY, {
+    stroke: borderColor,
+    "stroke-width": "1"
+  }));
+  for (const tick of ticks) {
+    const x = dateToX(tick);
+    if (x < chartLeft || x > chartLeft + chartWidth) continue;
+    parts.push(line(x, opts.headerHeight, x, totalHeight, {
+      stroke: trackColor,
+      "stroke-width": "1",
+      "clip-path": "url(#chart-clip)"
+    }));
+    parts.push(line(x, axisY - 4, x, axisY, { stroke: mutedColor, "stroke-width": "1" }));
+    parts.push(text(x + 3, axisY - 6, formatTick(tick, granularity), {
+      fill: mutedColor,
+      "font-size": "10",
+      "font-family": opts.fontFamily
+    }));
+  }
+  {
+    const blockRanges = [];
+    const blockStack = [];
+    for (let ri = 0; ri < rows.length; ri++) {
+      const row = rows[ri];
+      if (row.kind === "parallel-header" && row.block) blockStack.push({ block: row.block, rowStart: ri });
+      if (row.isLastInBlock && blockStack.length > 0) {
+        const entry = blockStack.pop();
+        blockRanges.push({ block: entry.block, rowStart: entry.rowStart, rowEnd: ri });
+      }
+    }
+    for (const br of blockRanges) {
+      const by = opts.headerHeight + br.rowStart * opts.rowHeight;
+      const bh = (br.rowEnd - br.rowStart + 1) * opts.rowHeight;
+      parts.push(line(opts.padding / 2, by + 4, opts.padding / 2, by + bh - 4, {
+        stroke: "#6366f1",
+        "stroke-width": "2",
+        opacity: "0.35"
+      }));
+    }
+  }
+  for (let ri = 0; ri < rows.length; ri++) {
+    const row = rows[ri];
+    const rowY = opts.headerHeight + ri * opts.rowHeight;
+    const midY = rowY + opts.rowHeight / 2;
+    if (row.kind === "parallel-header" && row.block) {
+      const indent = row.depth * 14 + opts.padding;
+      const blockName = (row.block.name ?? "(parallel)").toUpperCase();
+      parts.push(text(indent, midY + 4, blockName, {
+        fill: isDark ? "#818cf8" : "#6366f1",
+        "font-size": "9",
+        "font-weight": "700",
+        "letter-spacing": "0.08em",
+        "font-family": opts.fontFamily
+      }));
+      continue;
+    }
+    if (row.kind === "task" && row.task) {
+      const task = row.task;
+      const isSubtask = row.depth > 0;
+      const indent = row.depth * 14 + opts.padding;
+      const color = isDark ? STATUS_DARK[task.status] : STATUS_COLORS[task.status];
+      const isCancelled = task.status === "cancelled";
+      const isPending = task.status === "new" || task.status === "deferred" || task.status === "paused";
+      const lineColor = isCancelled ? mutedColor : color;
+      const mainOpacity = isCancelled ? 0.4 : isPending ? 0.6 : 1;
+      const sw = isSubtask ? 1.5 : 2;
+      const dotR = isSubtask ? 3 : 4;
+      parts.push(circle(indent + 4, midY, 2.5, {
+        fill: lineColor,
+        opacity: mainOpacity
+      }));
+      const labelText = task.name.length > 27 ? task.name.slice(0, 25) + "\u2026" : task.name;
+      parts.push(text(indent + 12, midY + 4, labelText, {
+        fill: isCancelled ? mutedColor : textColor,
+        "font-size": isSubtask ? "11" : "12",
+        "font-family": opts.fontFamily,
+        opacity: isCancelled ? "0.45" : "1"
+      }));
+      if (!task.computedStart || !task.computedEnd) continue;
+      const delayedMod = task.modifiers.find((m) => m.startsWith("delayed:"));
+      const blockedTimeMod = task.modifiers.find((m) => m.startsWith("blocked:"));
+      const taskEndDate = delayedMod && task.delayStart ? task.delayStart : task.computedEnd;
+      const x1 = dateToX(task.computedStart);
+      const x2 = Math.max(x1 + 5, dateToX(taskEndDate));
+      parts.push(line(chartLeft, midY, chartLeft + chartWidth, midY, {
+        stroke: trackColor,
+        "stroke-width": "1",
+        "clip-path": "url(#chart-clip)"
+      }));
+      if (blockedTimeMod && task.plannedStart && task.plannedEnd) {
+        const gx1 = dateToX(task.plannedStart);
+        const gx2 = Math.max(gx1 + 4, dateToX(task.plannedEnd));
+        parts.push(line(gx1, midY, gx2, midY, {
+          stroke: "#ef4444",
+          "stroke-width": String(sw - 0.5),
+          "stroke-dasharray": "3,3",
+          "stroke-linecap": "round",
+          opacity: "0.35",
+          "clip-path": "url(#chart-clip)"
+        }));
+        parts.push(circle(gx1, midY, dotR - 1, {
+          fill: "none",
+          stroke: "#ef4444",
+          "stroke-width": "1.5",
+          opacity: "0.35",
+          "clip-path": "url(#chart-clip)"
+        }));
+        parts.push(circle(gx2, midY, dotR - 1, {
+          fill: "none",
+          stroke: "#ef4444",
+          "stroke-width": "1.5",
+          opacity: "0.35",
+          "clip-path": "url(#chart-clip)"
+        }));
+        if (x1 > gx2 + 6) {
+          parts.push(line(gx2, midY, x1, midY, {
+            stroke: "#ef4444",
+            "stroke-width": "1",
+            "stroke-dasharray": "2,5",
+            opacity: "0.2",
+            "clip-path": "url(#chart-clip)"
+          }));
+        }
+      }
+      const dashArr = isPending ? "5,4" : void 0;
+      const span = x2 - x1;
+      if (task.progress != null && task.progress > 0 && !isCancelled) {
+        const progX = x1 + span * (task.progress / 100);
+        parts.push(line(x1, midY, x2, midY, {
+          stroke: lineColor,
+          "stroke-width": String(sw),
+          opacity: "0.2",
+          "stroke-linecap": "round",
+          "clip-path": "url(#chart-clip)",
+          ...dashArr ? { "stroke-dasharray": dashArr } : {}
+        }));
+        parts.push(line(x1, midY, progX, midY, {
+          stroke: lineColor,
+          "stroke-width": String(sw + 0.5),
+          "stroke-linecap": "round",
+          "clip-path": "url(#chart-clip)"
+        }));
+      } else {
+        parts.push(line(x1, midY, x2, midY, {
+          stroke: lineColor,
+          "stroke-width": String(sw),
+          opacity: String(mainOpacity),
+          "stroke-linecap": "round",
+          "clip-path": "url(#chart-clip)",
+          ...dashArr ? { "stroke-dasharray": dashArr } : {}
+        }));
+      }
+      parts.push(circle(x1, midY, dotR, {
+        fill: lineColor,
+        opacity: String(mainOpacity),
+        "clip-path": "url(#chart-clip)"
+      }));
+      if (task.status === "done") {
+        parts.push(circle(x2, midY, dotR, { fill: lineColor, "clip-path": "url(#chart-clip)" }));
+      } else {
+        parts.push(circle(x2, midY, dotR, {
+          fill: bgColor,
+          stroke: lineColor,
+          "stroke-width": "1.5",
+          opacity: String(mainOpacity),
+          "clip-path": "url(#chart-clip)"
+        }));
+      }
+      if (delayedMod && task.delayStart && task.computedEnd) {
+        const ox1 = dateToX(task.delayStart);
+        const ox2 = Math.max(ox1 + 5, dateToX(task.computedEnd));
+        parts.push(line(ox1, midY, ox2, midY, {
+          stroke: "#f59e0b",
+          "stroke-width": String(sw),
+          "stroke-dasharray": "4,3",
+          "stroke-linecap": "round",
+          opacity: "0.7",
+          "clip-path": "url(#chart-clip)"
+        }));
+        parts.push(circle(ox2, midY, dotR, {
+          fill: "none",
+          stroke: "#f59e0b",
+          "stroke-width": "1.5",
+          opacity: "0.7",
+          "clip-path": "url(#chart-clip)"
+        }));
+      }
+      if (task.modifiers.includes("deadline") && task.dueDate) {
+        const dlX = dateToX(/* @__PURE__ */ new Date(task.dueDate + "T00:00:00Z"));
+        parts.push(line(dlX, rowY + 3, dlX, rowY + opts.rowHeight - 3, {
+          stroke: "#ef4444",
+          "stroke-width": "1.5",
+          "stroke-dasharray": "2,2",
+          opacity: "0.6",
+          "clip-path": "url(#chart-clip)"
+        }));
+      }
+      const circleR = 8;
+      const visualEnd = delayedMod && task.delayStart && task.computedEnd ? dateToX(task.computedEnd) : x2;
+      if (task.assignees.length > 0) {
+        let cx = visualEnd + circleR + 5;
+        for (const assignee of task.assignees.slice(0, 3)) {
+          parts.push(circle(cx, midY, circleR, {
+            fill: bgColor,
+            stroke: lineColor,
+            "stroke-width": "1.5",
+            "clip-path": "url(#chart-clip)"
+          }));
+          parts.push(text(cx, midY + 3.5, initials(assignee), {
+            fill: textColor,
+            "font-size": "7",
+            "font-weight": "600",
+            "text-anchor": "middle",
+            "font-family": opts.fontFamily,
+            "clip-path": "url(#chart-clip)"
+          }));
+          cx += circleR * 1.9;
+        }
+      }
+      {
+        const nameX = x1 + dotR + 4;
+        const availW = chartLeft + chartWidth - nameX - 8;
+        if (availW > 30) {
+          const maxChars = Math.max(4, Math.floor(availW / 6.5));
+          const nameLabel = task.name.length > maxChars ? task.name.slice(0, maxChars - 1) + "\u2026" : task.name;
+          parts.push(text(nameX, midY - (isSubtask ? 5 : 6), nameLabel, {
+            fill: mutedColor,
+            "font-size": isSubtask ? "9" : "10",
+            "font-family": opts.fontFamily,
+            opacity: isCancelled ? "0.4" : "0.75",
+            "clip-path": "url(#chart-clip)"
+          }));
+        }
+      }
+      if (task.description) {
+        parts.push(`<rect x="0" y="${rowY}" width="${opts.width}" height="${opts.rowHeight}" fill="transparent" data-line="${task.line}" style="cursor:pointer"><title>${escapeXml(task.description)}</title></rect>`);
+      } else {
+        parts.push(rect(0, rowY, opts.width, opts.rowHeight, {
+          fill: "transparent",
+          "data-line": task.line,
+          style: "cursor:pointer"
+        }));
+      }
+    }
+    if (row.kind === "milestone" && row.milestone) {
+      const ms = row.milestone;
+      const indent = row.depth * 14 + opts.padding;
+      const labelText = ms.name.length > 27 ? ms.name.slice(0, 25) + "\u2026" : ms.name;
+      parts.push(text(indent + 12, midY + 4, labelText, {
+        fill: isDark ? "#fbbf24" : "#92400e",
+        "font-size": "11",
+        "font-style": "italic",
+        "font-family": opts.fontFamily
+      }));
+      if (!ms.computedDate) continue;
+      const dmx = dateToX(ms.computedDate);
+      const msR = row.depth > 0 ? 4 : 5;
+      if (ms.modifiers.includes("deadline")) {
+        parts.push(line(dmx, opts.headerHeight, dmx, totalHeight, {
+          stroke: "#ef4444",
+          "stroke-width": "1",
+          opacity: "0.2",
+          "clip-path": "url(#chart-clip)"
+        }));
+      }
+      parts.push(circle(dmx, midY, msR, {
+        fill: isDark ? "#fbbf24" : "#d97706",
+        "clip-path": "url(#chart-clip)"
+      }));
+      parts.push(circle(dmx, midY, msR - 2.5, {
+        fill: bgColor,
+        "clip-path": "url(#chart-clip)"
+      }));
+      parts.push(text(dmx + msR + 4, midY + 3.5, ms.name.slice(0, 18), {
+        fill: isDark ? "#fbbf24" : "#92400e",
+        "font-size": "9",
+        "font-weight": "600",
+        "font-family": opts.fontFamily,
+        "clip-path": "url(#chart-clip)"
+      }));
+    }
+  }
+  const today = /* @__PURE__ */ new Date();
+  today.setUTCHours(0, 0, 0, 0);
+  if (today >= minDate2 && today <= maxDate2) {
+    const tx = dateToX(today);
+    parts.push(line(tx, opts.headerHeight, tx, totalHeight, {
+      stroke: "#ef4444",
+      "stroke-width": "1",
+      opacity: "0.5"
+    }));
+    parts.push(circle(tx, opts.headerHeight, 3, { fill: "#ef4444", opacity: "0.7" }));
+  }
+  parts.push(line(chartLeft, 0, chartLeft, totalHeight, {
+    stroke: borderColor,
+    "stroke-width": "1",
+    opacity: "0.6"
+  }));
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${opts.width}" height="${totalHeight}" viewBox="0 0 ${opts.width} ${totalHeight}" font-family="${opts.fontFamily}">
+${parts.join("\n")}
+</svg>`;
+}
+
+// cli/serve.ts
+function parseArgs(argv) {
+  let folder2 = process.cwd();
+  let port = 3e3;
+  let noOpen2 = false;
+  for (let i = 0; i < argv.length; i++) {
+    if ((argv[i] === "--port" || argv[i] === "-p") && argv[i + 1]) {
+      port = parseInt(argv[++i], 10);
+    } else if (argv[i] === "--no-open") {
+      noOpen2 = true;
+    } else if (argv[i] === "--help" || argv[i] === "-h") {
+      process.stdout.write([
+        "",
+        "yatt [folder] [options]",
+        "",
+        "  folder          Directory to watch (default: current directory)",
+        "  --port, -p N    Port to listen on (default: 3000, auto-increments if busy)",
+        "  --no-open       Do not open the browser automatically",
+        "  --help, -h      Show this help",
+        ""
+      ].join("\n"));
+      process.exit(0);
+    } else if (!argv[i].startsWith("-")) {
+      folder2 = path.resolve(argv[i]);
+    }
+  }
+  return { folder: folder2, port, noOpen: noOpen2 };
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".svn", "dist", ".next", ".nuxt"]);
+function walkMdFiles(rootDir) {
+  const results = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && entry.name.endsWith(".md")) results.push(full);
+    }
+  }
+  walk(rootDir);
+  return results.sort();
+}
+function parseMdBlocks(source) {
+  const blocks = [];
+  const lines = source.split(/\r?\n/);
+  let state = "normal";
+  let fenceClose = "```";
+  let buf = [];
+  function flushProse() {
+    const t = buf.join("\n").trim();
+    if (t) blocks.push({ kind: "prose", text: t });
+    buf = [];
+  }
+  for (const line2 of lines) {
+    if (state === "yatt") {
+      if (line2.trimEnd() === fenceClose) {
+        blocks.push({ kind: "yatt", source: buf.join("\n") });
+        buf = [];
+        state = "normal";
+      } else {
+        buf.push(line2);
+      }
+      continue;
+    }
+    if (state === "fence") {
+      buf.push(line2);
+      if (line2.trimEnd() === fenceClose) state = "normal";
+      continue;
+    }
+    if (/^```yatt\s*$/.test(line2)) {
+      flushProse();
+      fenceClose = "```";
+      state = "yatt";
+      continue;
+    }
+    if (/^~~~yatt\s*$/.test(line2)) {
+      flushProse();
+      fenceClose = "~~~";
+      state = "yatt";
+      continue;
+    }
+    if (/^```/.test(line2)) {
+      buf.push(line2);
+      fenceClose = "```";
+      state = "fence";
+      continue;
+    }
+    if (/^~~~/.test(line2)) {
+      buf.push(line2);
+      fenceClose = "~~~";
+      state = "fence";
+      continue;
+    }
+    const hm = line2.match(/^(#{1,6})\s+(.+)$/);
+    if (hm) {
+      flushProse();
+      blocks.push({ kind: "heading", level: hm[1].length, text: hm[2] });
+      continue;
+    }
+    buf.push(line2);
+  }
+  flushProse();
+  return blocks;
+}
+function extractTasksFromItems(items) {
+  const tasks = [];
+  function fmt(d) {
+    return d ? d.toISOString().slice(0, 10) : void 0;
+  }
+  function walkTask(t, depth) {
+    const dotPrefix = ".".repeat(depth);
+    const info = {
+      name: t.name,
+      status: t.status,
+      assignees: t.assignees,
+      tags: t.tags,
+      depth,
+      dotPrefix,
+      line: t.line
+    };
+    if (t.priority) info.priority = t.priority;
+    if (t.progress !== void 0) info.progress = t.progress;
+    if (t.id) info.id = t.id;
+    if (t.duration) info.duration = `${t.duration.value}${t.duration.unit}`;
+    if (t.startDate) info.startDate = t.startDate;
+    if (t.dueDate) info.dueDate = t.dueDate;
+    if (t.after.length) info.after = t.after.map((d) => d.ids.join(d.logic === "or" ? "|" : ",")).join(",");
+    if (t.modifiers.length) info.modifiers = [...t.modifiers];
+    if (t.description) info.description = t.description;
+    const s = fmt(t.computedStart), e = fmt(t.computedEnd);
+    if (s) info.start = s;
+    if (e) info.end = e;
+    tasks.push(info);
+    for (const sub of t.subtasks) walkTask(sub, depth + 1);
+  }
+  function walk(its) {
+    for (const item of its) {
+      if (item.type === "task") walkTask(item, 0);
+      else if (item.type === "parallel") walk(item.items);
+    }
+  }
+  walk(items);
+  return tasks;
+}
+function renderYattBlock(source) {
+  const { doc, errors: parseErrors } = parse(source);
+  const validationErrors = validate(doc);
+  const scheduled = schedule(doc);
+  const html = renderGanttSVG(scheduled, { theme: "dark", width: 1100 });
+  const errors = [...parseErrors, ...validationErrors].map((e) => `Line ${e.line}: ${e.message}`);
+  const tasks = extractTasksFromItems(doc.items);
+  return { html, errors, tasks };
+}
+function renderFile(absPath) {
+  const source = fs.readFileSync(absPath, "utf8");
+  const blocks = parseMdBlocks(source);
+  return blocks.map((b) => {
+    if (b.kind === "yatt") {
+      const { html, errors, tasks } = renderYattBlock(b.source);
+      return { kind: "yatt", html, errors, tasks, source: b.source };
+    }
+    if (b.kind === "heading") return { kind: "heading", level: b.level, text: b.text };
+    return { kind: "prose", text: b.text };
+  });
+}
+function replaceYattBlock(fileSource, blockIdx, newSource) {
+  const lines = fileSource.split(/\r?\n/);
+  let idx = 0;
+  let scanState = "normal";
+  let fenceClose = "```";
+  let contentStart = -1;
+  let contentEnd = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const ln = lines[i];
+    if (scanState === "yatt") {
+      if (ln.trimEnd() === fenceClose) {
+        if (idx === blockIdx) {
+          contentEnd = i;
+          break;
+        }
+        idx++;
+        scanState = "normal";
+      }
+      continue;
+    }
+    if (scanState === "fence") {
+      if (ln.trimEnd() === fenceClose) scanState = "normal";
+      continue;
+    }
+    if (/^```yatt\s*$/.test(ln)) {
+      if (idx === blockIdx) contentStart = i + 1;
+      fenceClose = "```";
+      scanState = "yatt";
+      continue;
+    }
+    if (/^~~~yatt\s*$/.test(ln)) {
+      if (idx === blockIdx) contentStart = i + 1;
+      fenceClose = "~~~";
+      scanState = "yatt";
+      continue;
+    }
+    if (/^```/.test(ln)) {
+      fenceClose = "```";
+      scanState = "fence";
+      continue;
+    }
+    if (/^~~~/.test(ln)) {
+      fenceClose = "~~~";
+      scanState = "fence";
+      continue;
+    }
+  }
+  if (contentStart < 0 || contentEnd < 0) throw new Error(`YATT block ${blockIdx} not found`);
+  const newLines = newSource.split(/\r?\n/);
+  lines.splice(contentStart, contentEnd - contentStart, ...newLines);
+  return lines.join("\n");
+}
+var SseManager = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Set();
+  }
+  add(res) {
+    res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" });
+    res.write(":ok\n\n");
+    this.clients.add(res);
+    res.on("close", () => this.clients.delete(res));
+  }
+  broadcast(event) {
+    const msg = `data: ${event}
+
+`;
+    for (const res of this.clients) res.write(msg);
+  }
+};
+function watchFolder(rootDir, sse) {
+  let debounce = null;
+  const fire = () => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => sse.broadcast("reload"), 150);
+  };
+  try {
+    fs.watch(rootDir, { recursive: true }, (_e, f) => {
+      if (f && f.endsWith(".md")) fire();
+    });
+  } catch {
+    fs.watch(rootDir, {}, (_e, f) => {
+      if (f && f.endsWith(".md")) fire();
+    });
+  }
+}
+function openBrowser(url) {
+  try {
+    if (process.platform === "win32") execFile("explorer", [url], () => {
+    });
+    else if (process.platform === "darwin") execFile("open", [url], () => {
+    });
+    else execFile("xdg-open", [url], () => {
+    });
+  } catch {
+  }
+}
+function guardPath(rootDir, relPath) {
+  if (!relPath) return null;
+  const absPath = path.resolve(rootDir, relPath);
+  const safeRoot = rootDir.endsWith(path.sep) ? rootDir : rootDir + path.sep;
+  if (!absPath.startsWith(safeRoot) && absPath !== rootDir) return null;
+  return absPath;
+}
+var CSS = `
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+:root {
+  --bg:        #0d1117;
+  --panel:     #161b22;
+  --panel2:    #1c2128;
+  --border:    #30363d;
+  --text:      #e6edf3;
+  --muted:     #7d8590;
+  --accent:    #388bfd;
+  --accent-hi: #79c0ff;
+  --green:     #3fb950;
+  --red:       #f85149;
+  --orange:    #f0883e;
+  --yellow:    #d29922;
+  --purple:    #bc8cff;
+  --sidebar-w: 240px;
+  --topbar-h:  46px;
+}
+html, body { height: 100%; background: var(--bg); color: var(--text);
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+  font-size: 14px; overflow: hidden; }
+#app { display: flex; flex-direction: column; height: 100vh; }
+
+/* \u2500\u2500 topbar \u2500\u2500 */
+#topbar { flex: 0 0 var(--topbar-h); display: flex; align-items: center; gap: 10px;
+  padding: 0 14px; background: var(--panel); border-bottom: 1px solid var(--border); z-index: 10; }
+.logo { font-size: 13px; font-weight: 700; letter-spacing: 0.12em; color: var(--accent-hi);
+  text-transform: uppercase; flex-shrink: 0; }
+#folder-path { font-size: 11px; color: var(--muted); overflow: hidden; text-overflow: ellipsis;
+  white-space: nowrap; flex: 1; min-width: 0; }
+#view-tabs { display: flex; gap: 2px; flex-shrink: 0; }
+.tab { background: none; border: none; cursor: pointer; padding: 5px 12px;
+  font-size: 12px; color: var(--muted); border-radius: 4px;
+  transition: color 0.1s, background 0.1s; font-family: inherit; }
+.tab:hover { color: var(--text); background: rgba(255,255,255,0.06); }
+.tab.active { color: var(--accent-hi); background: rgba(56,139,253,0.12); }
+#save-status { font-size: 11px; color: var(--muted); flex-shrink: 0; min-width: 60px; text-align: right; }
+#save-status.unsaved { color: var(--orange); }
+#save-status.saved { color: var(--green); }
+#save-status.error { color: var(--red); }
+
+/* \u2500\u2500 git widget \u2500\u2500 */
+#git-widget { display: flex; align-items: center; gap: 6px; flex-shrink: 0; margin-left: auto; }
+#git-widget.hidden { display: none; }
+.git-branch { display: flex; align-items: center; gap: 4px; font-size: 11px; color: var(--muted);
+  background: var(--panel2); border: 1px solid var(--border); border-radius: 4px; padding: 2px 7px; }
+.git-dot { width: 7px; height: 7px; border-radius: 50%; background: var(--green); flex-shrink: 0; }
+.git-dot.dirty { background: var(--orange); }
+.git-count { font-size: 10px; color: var(--muted); display: flex; align-items: center; gap: 2px; }
+.git-count.ahead { color: #6a9fd8; }
+.git-count.behind { color: var(--orange); }
+.git-btn { background: var(--panel2); border: 1px solid var(--border); color: var(--text);
+  border-radius: 4px; padding: 2px 9px; font-size: 11px; cursor: pointer; white-space: nowrap; }
+.git-btn:hover { border-color: var(--accent); color: var(--accent-hi); }
+.git-btn:disabled { opacity: 0.4; cursor: default; }
+.git-btn.primary { border-color: var(--accent); color: var(--accent-hi); }
+#git-msg { font-size: 11px; max-width: 200px; overflow: hidden; text-overflow: ellipsis;
+  white-space: nowrap; flex-shrink: 0; }
+#git-msg.ok { color: var(--green); }
+#git-msg.err { color: var(--red); }
+/* commit modal */
+#git-commit-modal { position: fixed; inset: 0; background: rgba(0,0,0,0.6); z-index: 1001;
+  display: flex; align-items: center; justify-content: center; }
+#git-commit-modal.hidden { display: none; }
+#git-commit-box { background: var(--panel); border: 1px solid var(--border); border-radius: 10px;
+  padding: 20px; width: 360px; display: flex; flex-direction: column; gap: 12px; }
+#git-commit-box h3 { margin: 0; font-size: 14px; color: var(--text); }
+#git-commit-msg { width: 100%; box-sizing: border-box; background: var(--panel2); border: 1px solid var(--border);
+  color: var(--text); border-radius: 5px; padding: 8px 10px; font-size: 12px; font-family: inherit;
+  resize: vertical; min-height: 60px; }
+#git-commit-msg:focus { outline: none; border-color: var(--accent); }
+.git-commit-actions { display: flex; justify-content: flex-end; gap: 8px; }
+
+/* \u2500\u2500 workspace \u2500\u2500 */
+#workspace { flex: 1; display: flex; min-height: 0; }
+
+/* \u2500\u2500 sidebar \u2500\u2500 */
+#sidebar { flex: 0 0 var(--sidebar-w); overflow-y: auto; border-right: 1px solid var(--border);
+  background: var(--panel); scrollbar-width: thin; scrollbar-color: var(--border) transparent; }
+#sidebar::-webkit-scrollbar { width: 4px; }
+#sidebar::-webkit-scrollbar-thumb { background: var(--border); border-radius: 2px; }
+#sidebar-inner { padding: 6px 0; }
+.group-label { font-size: 10px; font-weight: 600; text-transform: uppercase;
+  letter-spacing: 0.08em; color: var(--muted); padding: 10px 14px 3px; }
+.file-item { display: block; padding: 5px 14px; font-size: 12px; color: var(--text);
+  cursor: pointer; text-decoration: none; white-space: nowrap; overflow: hidden;
+  text-overflow: ellipsis; border-left: 2px solid transparent; transition: background 0.1s; }
+.file-item:hover { background: rgba(56,139,253,0.08); }
+.file-item.active { background: rgba(56,139,253,0.14); color: var(--accent-hi); border-left-color: var(--accent); }
+
+/* \u2500\u2500 main \u2500\u2500 */
+#main { flex: 1; display: flex; flex-direction: column; min-width: 0; overflow: hidden; }
+.view-panel { flex: 1; overflow-y: auto; scrollbar-width: thin; scrollbar-color: var(--border) transparent; }
+.view-panel::-webkit-scrollbar { width: 6px; }
+.view-panel::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
+
+/* \u2500\u2500 document view \u2500\u2500 */
+#doc-content { max-width: 1200px; margin: 0 auto; padding: 28px 36px 80px; }
+.block-h1 { font-size: 24px; font-weight: 700; margin: 32px 0 12px;
+  padding-bottom: 8px; border-bottom: 1px solid var(--border); }
+.block-h2 { font-size: 18px; font-weight: 600; margin: 24px 0 8px; }
+.block-h3, .block-h4, .block-h5, .block-h6 { font-size: 14px; font-weight: 600; margin: 18px 0 6px; color: var(--muted); }
+.prose { line-height: 1.65; color: var(--text); margin: 12px 0; }
+.prose p { margin: 6px 0; }
+.prose ul, .prose ol { padding-left: 20px; margin: 6px 0; }
+.prose li { margin: 3px 0; }
+.prose strong { font-weight: 600; }
+.prose em { font-style: italic; }
+.prose a { color: var(--accent-hi); }
+.prose h1,.prose h2,.prose h3,.prose h4 { font-weight: 600; margin: 14px 0 6px; }
+.prose blockquote { border-left: 2px solid var(--border); padding-left: 12px; color: var(--muted); margin: 8px 0; }
+.prose hr { border: none; border-top: 1px solid var(--border); margin: 16px 0; }
+.prose code { font-family: ui-monospace, monospace; font-size: 12px;
+  background: var(--panel2); padding: 1px 5px; border-radius: 3px; color: var(--accent-hi); }
+.prose pre { background: var(--panel2); border: 1px solid var(--border); border-radius: 6px;
+  padding: 14px 16px; overflow-x: auto; margin: 10px 0; }
+.prose pre code { background: none; padding: 0; font-size: 12px; color: var(--text); }
+.prose table { border-collapse: collapse; width: 100%; margin: 10px 0; font-size: 13px; }
+.prose th { text-align: left; padding: 6px 12px; background: var(--panel2);
+  border: 1px solid var(--border); font-weight: 600; }
+.prose td { padding: 6px 12px; border: 1px solid var(--border); }
+.prose tr:nth-child(even) td { background: rgba(255,255,255,0.02); }
+
+/* \u2500\u2500 yatt control (embedded per-block) \u2500\u2500 */
+.yatt-ctrl { margin: 16px 0; border: 1px solid var(--border); border-radius: 8px; overflow: auto;
+  display: flex; flex-direction: column; resize: vertical; min-height: 400px; }
+.yatt-ctrl-bar { display: flex; gap: 2px; padding: 4px 8px; flex: 0 0 auto;
+  border-bottom: 1px solid var(--border); background: var(--panel2); }
+.yatt-ctrl-tab { background: none; border: none; cursor: pointer; padding: 3px 10px;
+  font-size: 11px; color: var(--muted); border-radius: 3px;
+  transition: color 0.1s, background 0.1s; font-family: inherit; }
+.yatt-ctrl-tab:hover { color: var(--text); background: rgba(255,255,255,0.06); }
+.yatt-ctrl-tab.active { color: var(--accent-hi); background: rgba(56,139,253,0.12); }
+.yatt-ctrl-body { flex: 1; min-height: 0; display: flex; flex-direction: column; overflow: auto; }
+.yatt-ctrl-panel { display: none; }
+.yatt-ctrl-panel.active { display: flex; flex-direction: column; flex: 1; min-height: 0; overflow: auto; }
+.yatt-ctrl-panel[data-panel="timeline"] svg { max-width: 100%; height: auto; display: block; }
+.yatt-errors { background: rgba(248,81,73,0.08); border-bottom: 1px solid rgba(248,81,73,0.25);
+  padding: 6px 12px; font-size: 11px; color: var(--red); font-family: ui-monospace, monospace; }
+
+/* \u2500\u2500 kanban (inside control and shared atoms) \u2500\u2500 */
+.ctrl-kanban { display: flex; gap: 10px; padding: 12px; overflow-x: auto; align-items: flex-start; }
+.k-col { flex: 0 0 200px; background: var(--bg); border-radius: 6px;
+  border: 1px solid var(--border); display: flex; flex-direction: column; max-height: 360px; }
+.k-col.empty { flex: 0 0 32px; cursor: default; }
+.k-col.empty .k-col-header { display: none; }
+.k-col.empty .k-cards { display: none; }
+.k-col-empty-label { display: none; }
+.k-col.empty .k-col-empty-label { display: flex; flex-direction: column; align-items: center;
+  justify-content: center; height: 100%; gap: 8px; padding: 10px 0; }
+.k-col-empty-line { width: 3px; border-radius: 2px; flex-shrink: 0; min-height: 24px; flex: 1; max-height: 60px; }
+.k-col-empty-title { writing-mode: vertical-rl; text-orientation: mixed; transform: rotate(180deg);
+  font-size: 9px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.08em; color: var(--muted); }
+.k-col-header { padding: 8px 12px; border-bottom: 1px solid var(--border);
+  display: flex; align-items: center; gap: 7px; flex-shrink: 0; }
+.k-col-line { width: 3px; height: 12px; border-radius: 2px; flex-shrink: 0; }
+.k-col-title { font-size: 10px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.07em; flex: 1; }
+.k-col-count { font-size: 11px; color: var(--muted); }
+.k-cards { overflow-y: auto; padding: 6px; display: flex; flex-direction: column;
+  gap: 5px; scrollbar-width: thin; scrollbar-color: var(--border) transparent; }
+.k-cards::-webkit-scrollbar { width: 3px; }
+.k-cards::-webkit-scrollbar-thumb { background: var(--border); border-radius: 2px; }
+.k-card { background: var(--panel); border: 1px solid var(--border); border-radius: 5px;
+  padding: 8px 10px; transition: border-color 0.12s; }
+.k-card:hover { border-color: var(--accent); }
+.k-card-name { font-size: 11px; color: var(--text); line-height: 1.4; margin-bottom: 3px; }
+.k-card-desc { font-size: 10px; color: var(--muted); line-height: 1.4; margin-bottom: 5px; font-style: italic; }
+.k-shift-badge { display: inline-flex; align-items: center; gap: 3px; font-size: 10px; font-weight: 600;
+  border-radius: 3px; padding: 1px 5px; margin-right: 3px; }
+.k-shift-badge.delayed { background: rgba(245,158,11,0.15); color: #f59e0b; }
+.k-shift-badge.blocked { background: rgba(239,68,68,0.15); color: #ef4444; }
+.k-card-shifts { display: flex; gap: 4px; flex-wrap: wrap; margin-bottom: 5px; }
+.k-card-meta { display: flex; align-items: center; gap: 5px; flex-wrap: wrap; }
+.k-progress { height: 2px; background: var(--border); border-radius: 1px; margin-top: 6px; overflow: hidden; }
+.k-progress-fill { height: 100%; border-radius: 1px; background: var(--accent); }
+.k-priority { font-size: 10px; padding: 1px 5px; border-radius: 3px;
+  background: rgba(255,255,255,0.06); color: var(--muted); }
+.k-priority[data-p="critical"] { color: var(--red); }
+.k-priority[data-p="high"] { color: var(--orange); }
+
+/* \u2500\u2500 people (inside control) \u2500\u2500 */
+.ctrl-people { padding: 12px 16px; display: flex; flex-direction: column; gap: 12px; }
+.person-card { background: var(--bg); border: 1px solid var(--border); border-radius: 6px; overflow: hidden; }
+.person-header { display: flex; align-items: center; gap: 10px; padding: 10px 14px;
+  border-bottom: 1px solid var(--border); }
+.person-name { font-size: 12px; font-weight: 600; }
+.person-count { font-size: 11px; color: var(--muted); margin-top: 1px; }
+.ptask-row { display: flex; align-items: center; gap: 8px; padding: 6px 14px;
+  border-bottom: 1px solid var(--border); }
+.ptask-row:last-child { border-bottom: none; }
+.ptask-name { font-size: 12px; flex: 1; }
+.ptask-priority { font-size: 10px; color: var(--muted); }
+.ptask-priority[data-p="critical"] { color: var(--red); }
+.ptask-priority[data-p="high"] { color: var(--orange); }
+.ptask-prog { font-size: 10px; color: var(--muted); font-family: ui-monospace, monospace; }
+
+/* \u2500\u2500 markdown/edit view \u2500\u2500 */
+#view-markdown { display: flex; flex-direction: column; overflow: hidden; }
+#view-markdown.view-panel { overflow: hidden; }
+.view-panel[hidden] { display: none !important; }
+#editor { display: block; flex: 1 1 0; min-height: 0; width: 100%; resize: none;
+  background: var(--bg); color: var(--text); border: none; outline: none;
+  padding: 24px 32px; font-family: ui-monospace, 'Cascadia Code', 'Fira Code', monospace;
+  font-size: 13px; line-height: 1.65; tab-size: 2; }
+
+/* \u2500\u2500 yatt source panel (read-only) \u2500\u2500 */
+.yatt-src { padding: 16px; font-family: ui-monospace, 'Cascadia Code', monospace;
+  font-size: 12px; line-height: 1.6; overflow-x: auto;
+  background: var(--bg); color: var(--text); white-space: pre; margin: 0; }
+
+/* \u2500\u2500 yatt inline block editor \u2500\u2500 */
+.yatt-block-editor { display: block; width: 100%; flex: 1; min-height: 0; padding: 14px 16px;
+  font-family: ui-monospace, 'Cascadia Code', 'Fira Code', monospace;
+  font-size: 12px; line-height: 1.6; background: var(--bg); color: var(--text);
+  border: none; outline: none; resize: none; tab-size: 2; }
+.yatt-block-bar { display: flex; align-items: center; padding: 4px 12px;
+  border-top: 1px solid var(--border); background: var(--panel2); min-height: 26px; }
+.yatt-block-status { font-size: 10px; }
+
+/* \u2500\u2500 task edit modal \u2500\u2500 */
+#task-edit-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.65); z-index: 1000;
+  display: flex; align-items: center; justify-content: center; }
+#task-edit-overlay.hidden { display: none; }
+#task-edit-modal { background: var(--panel); border: 1px solid var(--border); border-radius: 10px;
+  padding: 22px 24px; width: 500px; max-height: 88vh; overflow-y: auto;
+  scrollbar-width: thin; scrollbar-color: var(--border) transparent; }
+.te-title { font-size: 15px; font-weight: 700; margin-bottom: 16px; color: var(--text); }
+.te-row { display: grid; gap: 10px; margin-bottom: 10px; }
+.te-row.cols-2 { grid-template-columns: 1fr 1fr; }
+.te-row.cols-3 { grid-template-columns: 1fr 1fr 1fr; }
+.te-field label { display: block; font-size: 10px; font-weight: 600; text-transform: uppercase;
+  letter-spacing: 0.06em; color: var(--muted); margin-bottom: 4px; }
+.te-field input, .te-field select { width: 100%; background: var(--bg); border: 1px solid var(--border);
+  border-radius: 5px; color: var(--text); padding: 5px 8px; font-size: 12px; font-family: inherit;
+  outline: none; transition: border-color 0.1s; }
+.te-field input:focus, .te-field select:focus { border-color: var(--accent); }
+.te-field textarea { width: 100%; background: var(--bg); border: 1px solid var(--border);
+  border-radius: 5px; color: var(--text); padding: 5px 8px; font-size: 12px; font-family: inherit;
+  outline: none; transition: border-color 0.1s; resize: vertical; min-height: 56px; box-sizing: border-box; }
+.te-field textarea:focus { border-color: var(--accent); }
+.te-field select option { background: var(--panel); }
+.te-actions { display: flex; align-items: center; gap: 8px; margin-top: 18px; }
+.te-save-msg { font-size: 11px; color: var(--muted); flex: 1; }
+.te-btn { padding: 5px 16px; border-radius: 5px; border: none; cursor: pointer;
+  font-size: 12px; font-family: inherit; font-weight: 500; transition: opacity 0.1s; }
+.te-btn-primary { background: var(--accent); color: #fff; }
+.te-btn-primary:hover { opacity: 0.85; }
+.te-btn-ghost { background: rgba(255,255,255,0.06); color: var(--text); border: 1px solid var(--border); }
+.te-btn-ghost:hover { background: rgba(255,255,255,0.1); }
+
+/* \u2500\u2500 kanban drag \u2500\u2500 */
+.k-col.drag-over .k-cards { background: rgba(56,139,253,0.08); border-radius: 0 0 6px 6px; }
+.k-card.dragging { opacity: 0.35; }
+.k-card[data-line] { cursor: pointer; }
+.k-card[data-line]:hover { border-color: var(--accent-hi); }
+.ptask-row[data-line] { cursor: pointer; }
+.ptask-row[data-line]:hover { background: rgba(56,139,253,0.06); }
+
+/* \u2500\u2500 gantt hover card \u2500\u2500 */
+#gantt-hover-card { display:none; position:fixed; z-index:9999; pointer-events:none;
+  background: var(--panel); border: 1px solid var(--border); border-radius: 8px;
+  padding: 10px 12px; min-width: 180px; max-width: 260px;
+  box-shadow: 0 8px 24px rgba(0,0,0,0.25); font-size: 12px; }
+.ghc-name { font-size: 13px; font-weight: 600; color: var(--text); margin-bottom: 6px; line-height: 1.3; }
+.ghc-row { display: flex; align-items: center; gap: 6px; color: var(--muted); margin-bottom: 3px; font-size: 11px; }
+.ghc-status { display: inline-flex; align-items: center; gap: 4px; }
+.ghc-dot { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
+.ghc-desc { color: var(--muted); font-style: italic; font-size: 11px; margin-top: 6px;
+  padding-top: 6px; border-top: 1px solid var(--border); line-height: 1.4; }
+.ghc-tags { display: flex; flex-wrap: wrap; gap: 3px; margin-top: 5px; }
+.ghc-tag { background: var(--border); color: var(--muted); border-radius: 3px; padding: 1px 5px; font-size: 10px; }
+
+/* \u2500\u2500 shared atoms \u2500\u2500 */
+.sdot { display: inline-block; width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
+.avatar { display: inline-flex; align-items: center; justify-content: center;
+  width: 20px; height: 20px; border-radius: 50%; background: var(--border);
+  font-size: 9px; font-weight: 700; color: var(--text); flex-shrink: 0; }
+.avatar-lg { width: 32px; height: 32px; font-size: 11px; }
+.loading { color: var(--muted); padding: 40px; text-align: center; font-size: 13px; }
+.err { color: var(--red) !important; }
+`;
+var JS = `
+var state = {
+  files: [], currentFile: null, view: 'view',
+  blocks: null, source: null, saveStatus: '', saveTimer: null,
+  editTask: null, editCtrlId: null, editBidx: null
+};
+
+// Persists the active panel for each yatt ctrl across SSE reloads
+var ctrlViews = {};
+
+var STATUS_COLOR = {
+  'new':'#7d8590','active':'#388bfd','done':'#3fb950','blocked':'#f85149',
+  'at-risk':'#f0883e','deferred':'#bc8cff','cancelled':'#30363d',
+  'review':'#d29922','paused':'#484f58'
+};
+var STATUS_LABEL = {
+  'new':'New','active':'Active','done':'Done','blocked':'Blocked',
+  'at-risk':'At Risk','deferred':'Deferred','cancelled':'Cancelled',
+  'review':'Review','paused':'Paused'
+};
+var KANBAN_COLS = ['new','active','review','blocked','paused','done','cancelled'];
+
+var STATUS_SIGIL = {
+  'new':' ','active':'~','done':'x','blocked':'!',
+  'at-risk':'?','deferred':'>','cancelled':'_','review':'=','paused':'o'
+};
+
+// \u2500\u2500 Task serializer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function serializeTaskLine(t) {
+  var sig = STATUS_SIGIL[t.status] || ' ';
+  var dp = t.dotPrefix || '';
+  var head = (dp ? dp + ' ' : '') + '[' + sig + '] ' + (t.name || '');
+  var fields = [];
+  if (t.id) fields.push('id:' + t.id);
+  if (t.duration) fields.push(t.duration);
+  if (t.assignees && t.assignees.length) fields.push(t.assignees.map(function(a){return '@'+a;}).join(' '));
+  if (t.tags && t.tags.length) fields.push(t.tags.map(function(a){return '#'+a;}).join(' '));
+  if (t.priority && t.priority !== 'normal') fields.push('!' + t.priority);
+  if (t.progress != null && t.progress !== '') fields.push('%' + t.progress);
+  if (t.startDate) fields.push('>' + t.startDate);
+  if (t.dueDate) fields.push('<' + t.dueDate);
+  if (t.after) fields.push('after:' + t.after);
+  if (t.modifiers && t.modifiers.length) t.modifiers.forEach(function(m) {
+    var shiftMatch = m.match(/^(delayed|blocked):(.+)$/);
+    if (shiftMatch) { fields.push(shiftMatch[1] + ' ' + shiftMatch[2]); }
+    else { fields.push('+' + m); }
+  });
+  return head + (fields.length ? ' | ' + fields.join(' | ') : '');
+}
+
+function patchBlockSource(source, lineNum, newLine) {
+  var lines = source.split('\\n');
+  if (lineNum >= 1 && lineNum <= lines.length) lines[lineNum - 1] = newLine;
+  return lines.join('\\n');
+}
+
+function patchBlockSourceWithDescription(source, lineNum, newLine, descText) {
+  var lines = source.split('\\n');
+  if (lineNum < 1 || lineNum > lines.length) return source;
+  // Count existing description comment lines immediately after the task line
+  var oldDescCount = 0;
+  var idx = lineNum; // 0-based index of the line after the task
+  while (idx < lines.length && lines[idx].trimStart().startsWith('//')) {
+    oldDescCount++;
+    idx++;
+  }
+  // Build replacement: task line + optional description comment lines
+  var newLines = [newLine];
+  if (descText && descText.trim()) {
+    descText.trim().split('\\n').forEach(function(dl) {
+      newLines.push('// ' + dl.trim());
+    });
+  }
+  Array.prototype.splice.apply(lines, [lineNum - 1, 1 + oldDescCount].concat(newLines));
+  return lines.join('\\n');
+}
+
+function saveBlock(bidx, newSource, onDone) {
+  if (!state.currentFile) return;
+  // Update local cache so in-flight UI doesn't see stale source
+  var yblocks = (state.blocks || []).filter(function(b){ return b.kind === 'yatt'; });
+  if (yblocks[bidx]) yblocks[bidx].source = newSource;
+  fetch('/api/save-block?p=' + encodeURIComponent(state.currentFile) + '&idx=' + bidx, {
+    method: 'POST', headers: {'Content-Type':'text/plain;charset=utf-8'}, body: newSource
+  }).then(function(r) {
+    if (r.ok) { if (onDone) onDone(null); refreshGitStatus(); }
+    else r.json().then(function(d){ if (onDone) onDone(d.error || 'Error'); });
+  }).catch(function(e){ if (onDone) onDone(e.message); });
+}
+
+// \u2500\u2500 Task edit popup \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function openTaskEdit(task) {
+  if (!task) return;
+  state.editTask = task;
+  document.getElementById('te-name').value = task.name || '';
+  document.getElementById('te-status').value = task.status || 'new';
+  document.getElementById('te-assignees').value = (task.assignees||[]).map(function(a){return '@'+a;}).join(' ');
+  document.getElementById('te-tags').value = (task.tags||[]).map(function(a){return '#'+a;}).join(' ');
+  document.getElementById('te-priority').value = task.priority || 'normal';
+  document.getElementById('te-progress').value = task.progress != null ? task.progress : '';
+  document.getElementById('te-duration').value = task.duration || '';
+  document.getElementById('te-startdate').value = task.startDate || '';
+  document.getElementById('te-duedate').value = task.dueDate || '';
+  document.getElementById('te-id').value = task.id || '';
+  document.getElementById('te-after').value = task.after || '';
+  document.getElementById('te-description').value = task.description || '';
+  var mods = task.modifiers || [];
+  var delayedMod = mods.find(function(m){ return m.match(/^delayed:/); });
+  var blockedMod = mods.find(function(m){ return m.match(/^blocked:/); });
+  document.getElementById('te-delayed').value = delayedMod ? delayedMod.split(':')[1] : '';
+  document.getElementById('te-blocked').value = blockedMod ? blockedMod.split(':')[1] : '';
+  document.getElementById('te-save-msg').textContent = '';
+  document.getElementById('task-edit-overlay').classList.remove('hidden');
+  setTimeout(function(){ document.getElementById('te-name').focus(); }, 50);
+}
+
+function closeTaskEdit() {
+  document.getElementById('task-edit-overlay').classList.add('hidden');
+  state.editTask = null;
+}
+
+function saveTaskEdit() {
+  var task = state.editTask;
+  if (!task) return;
+  var updated = {};
+  for (var k in task) updated[k] = task[k];
+  updated.name = document.getElementById('te-name').value.trim();
+  updated.status = document.getElementById('te-status').value;
+  var ar = document.getElementById('te-assignees').value.trim();
+  updated.assignees = ar ? ar.split(/\\s+/).map(function(a){return a.replace(/^@/,'');}).filter(Boolean) : [];
+  var tr = document.getElementById('te-tags').value.trim();
+  updated.tags = tr ? tr.split(/\\s+/).map(function(a){return a.replace(/^#/,'');}).filter(Boolean) : [];
+  updated.priority = document.getElementById('te-priority').value || 'normal';
+  var pg = document.getElementById('te-progress').value;
+  updated.progress = pg !== '' ? parseInt(pg, 10) : null;
+  updated.duration = document.getElementById('te-duration').value.trim() || null;
+  updated.startDate = document.getElementById('te-startdate').value.trim() || null;
+  updated.dueDate = document.getElementById('te-duedate').value.trim() || null;
+  updated.id = document.getElementById('te-id').value.trim() || null;
+  updated.after = document.getElementById('te-after').value.trim() || null;
+  updated.description = document.getElementById('te-description').value.trim() || null;
+  // Rebuild modifiers: keep non-shift ones, then append updated delayed/blocked
+  var baseMods = (updated.modifiers || []).filter(function(m){
+    return !m.match(/^(delayed|blocked):/);
+  });
+  var delayedVal = document.getElementById('te-delayed').value.trim();
+  var blockedVal = document.getElementById('te-blocked').value.trim();
+  if (delayedVal) baseMods.push('delayed:' + delayedVal);
+  if (blockedVal) baseMods.push('blocked:' + blockedVal);
+  updated.modifiers = baseMods;
+
+  var bidx = state.editTask.bidx;
+  var yblocks = (state.blocks || []).filter(function(b){ return b.kind === 'yatt'; });
+  var block = yblocks[bidx];
+  if (!block || !block.source) {
+    document.getElementById('te-save-msg').style.color = 'var(--red)';
+    document.getElementById('te-save-msg').textContent = 'Error: block source not found';
+    return;
+  }
+  var newLine = serializeTaskLine(updated);
+  var newSource = patchBlockSourceWithDescription(block.source, task.line, newLine, updated.description);
+  var msgEl = document.getElementById('te-save-msg');
+  msgEl.style.color = 'var(--muted)'; msgEl.textContent = 'Saving...';
+  saveBlock(bidx, newSource, function(err) {
+    if (err) { msgEl.style.color='var(--red)'; msgEl.textContent='Error: '+err; }
+    else { closeTaskEdit(); }
+  });
+}
+
+// \u2500\u2500 Yatt ctrl init (called after each block renders) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function findTask(bidx, line) {
+  var yblocks = (state.blocks || []).filter(function(b){ return b.kind === 'yatt'; });
+  var block = yblocks[bidx];
+  if (!block) return null;
+  return (block.tasks || []).find(function(t){ return t.line === line; }) || null;
+}
+
+function initYattCtrl(ctrlId, bidx) {
+  var ctrl = document.getElementById(ctrlId);
+  if (!ctrl) return;
+  ctrl.setAttribute('data-bidx', bidx);
+
+  // Timeline: click + hover on task rows
+  var svgEl = ctrl.querySelector('[data-panel="timeline"] svg');
+  if (svgEl) {
+    svgEl.addEventListener('click', function(e) {
+      var el = e.target;
+      while (el && el !== svgEl) {
+        var dl = el.getAttribute ? el.getAttribute('data-line') : null;
+        if (dl) {
+          var task = findTask(bidx, parseInt(dl));
+          if (task) { task.bidx = bidx; openTaskEdit(task); }
+          return;
+        }
+        el = el.parentElement;
+      }
+    });
+    svgEl.addEventListener('mousemove', function(e) {
+      var el = e.target;
+      while (el && el !== svgEl) {
+        var dl = el.getAttribute ? el.getAttribute('data-line') : null;
+        if (dl) {
+          var task = findTask(bidx, parseInt(dl));
+          if (task) { showGanttHoverCard(task, e.clientX, e.clientY); return; }
+        }
+        el = el.parentElement;
+      }
+      hideGanttHoverCard();
+    });
+    svgEl.addEventListener('mouseleave', hideGanttHoverCard);
+  }
+
+  // Kanban: click-to-edit + drag-drop
+  var kbEl = ctrl.querySelector('[data-panel="kanban"] .ctrl-kanban');
+  if (kbEl) initKanban(kbEl, bidx);
+
+  // People: click-to-edit
+  var peEl = ctrl.querySelector('[data-panel="people"]');
+  if (peEl) {
+    peEl.querySelectorAll('.ptask-row[data-line]').forEach(function(row) {
+      row.addEventListener('click', function() {
+        var task = findTask(bidx, parseInt(row.getAttribute('data-line')));
+        if (task) { task.bidx = bidx; openTaskEdit(task); }
+      });
+    });
+  }
+
+  // Markdown tab: auto-save textarea
+  var mdPanel = ctrl.querySelector('[data-panel="markdown"]');
+  if (mdPanel) {
+    var ta = mdPanel.querySelector('.yatt-block-editor');
+    var statusEl = mdPanel.querySelector('.yatt-block-status');
+    if (ta) {
+      var bsTimer = null;
+      ta.addEventListener('input', function() {
+        if (bsTimer) clearTimeout(bsTimer);
+        if (statusEl) { statusEl.style.color = 'var(--orange)'; statusEl.textContent = 'Unsaved'; }
+        bsTimer = setTimeout(function() {
+          bsTimer = null;
+          saveBlock(bidx, ta.value, function(err) {
+            if (!statusEl) return;
+            statusEl.textContent = err ? 'Error: '+err : 'Saved';
+            statusEl.style.color = err ? 'var(--red)' : 'var(--green)';
+            if (!err) setTimeout(function(){ statusEl.textContent=''; }, 2000);
+          });
+        }, 1200);
+      });
+    }
+  }
+}
+
+function initKanban(kbEl, bidx) {
+  var dragging = null;
+  kbEl.querySelectorAll('.k-card[data-line]').forEach(function(card) {
+    card.setAttribute('draggable', 'true');
+    card.addEventListener('click', function() {
+      if (card.classList.contains('dragging')) return;
+      var task = findTask(bidx, parseInt(card.getAttribute('data-line')));
+      if (task) { task.bidx = bidx; openTaskEdit(task); }
+    });
+    card.addEventListener('dragstart', function(e) {
+      dragging = card; card.classList.add('dragging');
+      e.dataTransfer.effectAllowed = 'move';
+      e.dataTransfer.setData('text/plain', card.getAttribute('data-line'));
+    });
+    card.addEventListener('dragend', function() {
+      card.classList.remove('dragging'); dragging = null;
+    });
+  });
+  kbEl.querySelectorAll('.k-col[data-status]').forEach(function(col) {
+    var newStatus = col.getAttribute('data-status');
+    col.addEventListener('dragover', function(e) { e.preventDefault(); col.classList.add('drag-over'); });
+    col.addEventListener('dragleave', function() { col.classList.remove('drag-over'); });
+    col.addEventListener('drop', function(e) {
+      e.preventDefault(); col.classList.remove('drag-over');
+      var tline = parseInt(e.dataTransfer.getData('text/plain') || '0');
+      var task = findTask(bidx, tline);
+      if (!task || task.status === newStatus) return;
+      var yblocks = (state.blocks||[]).filter(function(b){return b.kind==='yatt';});
+      var block = yblocks[bidx];
+      if (!block||!block.source) return;
+      // Update in memory immediately
+      task.status = newStatus;
+      var updated = {}; for (var k in task) updated[k]=task[k];
+      var newSource = patchBlockSource(block.source, task.line, serializeTaskLine(updated));
+      block.source = newSource;
+      // Rebuild kanban in-place so we stay on the kanban tab
+      kbEl.innerHTML = buildKanbanHtml(block.tasks || []);
+      initKanban(kbEl, bidx);
+      saveBlock(bidx, newSource, null);
+    });
+  });
+}
+
+function esc(s) {
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+function sdot(status) {
+  var c = STATUS_COLOR[status] || '#7d8590';
+  return '<span class="sdot" style="background:' + c + '" title="' + esc(status) + '"></span>';
+}
+function shiftBadges(task) {
+  var html = '';
+  var mods = task.modifiers || [];
+  mods.forEach(function(m) {
+    var dm = m.match(/^(delayed|blocked):(.+)$/);
+    if (dm) html += '<span class="k-shift-badge ' + dm[1] + '" title="' + dm[1] + ' ' + dm[2] + '">' +
+      (dm[1] === 'delayed' ? '\u23F1' : '\u{1F6AB}') + ' ' + dm[2] + '</span>';
+  });
+  return html;
+}
+function avatarEl(name, large) {
+  var clean = name.replace(/[^a-zA-Z]/g,'');
+  var init = (clean.slice(0,2) || name.slice(0,2)).toUpperCase();
+  return '<span class="' + (large ? 'avatar avatar-lg' : 'avatar') + '" title="@' + esc(name) + '">' + esc(init) + '</span>';
+}
+
+var _ghcTask = null;
+function showGanttHoverCard(task, mx, my) {
+  var card = document.getElementById('gantt-hover-card');
+  if (!card) return;
+  if (_ghcTask === task) {
+    // Just reposition
+    positionGhc(card, mx, my);
+    return;
+  }
+  _ghcTask = task;
+  var STATUS_COLOR_MAP = {
+    new:'#93a8c4', active:'#6a9fd8', done:'#6aab85', blocked:'#c97070',
+    'at-risk':'#c9a04a', deferred:'#a892cc', cancelled:'#8a96a6',
+    review:'#8e7ec4', paused:'#7a90a6'
+  };
+  var dotColor = STATUS_COLOR_MAP[task.status] || '#94a3b8';
+  var html = '<div class="ghc-name">' + esc(task.name) + '</div>';
+  html += '<div class="ghc-row ghc-status"><span class="ghc-dot" style="background:' + dotColor + '"></span>' + esc(task.status) + '</div>';
+  if (task.assignees && task.assignees.length) {
+    html += '<div class="ghc-row">\u{1F464} ' + task.assignees.map(function(a){ return '@'+esc(a); }).join(', ') + '</div>';
+  }
+  if (task.progress != null) {
+    html += '<div class="ghc-row">\u25D0 ' + task.progress + '%</div>';
+  }
+  if (task.startDate || task.dueDate) {
+    html += '<div class="ghc-row">\u{1F4C5} ' + esc(task.startDate || '?') + (task.dueDate ? ' \u2192 ' + esc(task.dueDate) : '') + '</div>';
+  }
+  if (task.duration) {
+    html += '<div class="ghc-row">\u23F3 ' + esc(task.duration.value + task.duration.unit) + '</div>';
+  }
+  var mods = (task.modifiers || []);
+  var delayedM = mods.find(function(m){ return m.match(/^delayed:/); });
+  var blockedM = mods.find(function(m){ return m.match(/^blocked:/); });
+  if (delayedM) html += '<div class="ghc-row" style="color:#c9a04a">\u23F1 delayed ' + esc(delayedM.split(':')[1]) + '</div>';
+  if (blockedM) html += '<div class="ghc-row" style="color:#c97070">\u{1F6AB} blocked ' + esc(blockedM.split(':')[1]) + '</div>';
+  if (task.tags && task.tags.length) {
+    html += '<div class="ghc-tags">' + task.tags.map(function(t){ return '<span class="ghc-tag">#'+esc(t)+'</span>'; }).join('') + '</div>';
+  }
+  if (task.description) {
+    html += '<div class="ghc-desc">' + esc(task.description) + '</div>';
+  }
+  card.innerHTML = html;
+  card.style.display = 'block';
+  positionGhc(card, mx, my);
+}
+function positionGhc(card, mx, my) {
+  var pad = 14;
+  var w = card.offsetWidth || 220;
+  var h = card.offsetHeight || 120;
+  var left = mx + pad;
+  var top  = my - h / 2;
+  if (left + w > window.innerWidth - 8) left = mx - w - pad;
+  if (top < 8) top = 8;
+  if (top + h > window.innerHeight - 8) top = window.innerHeight - h - 8;
+  card.style.left = left + 'px';
+  card.style.top  = top  + 'px';
+}
+function hideGanttHoverCard() {
+  _ghcTask = null;
+  var card = document.getElementById('gantt-hover-card');
+  if (card) card.style.display = 'none';
+}
+function inlineMd(s) {
+  var r = esc(s).replace(/\`([^\`]+)\`/g,'<code>$1</code>');
+  return r
+    .replace(/\\*\\*(.+?)\\*\\*/g,'<strong>$1</strong>')
+    .replace(/__(.+?)__/g,'<strong>$1</strong>')
+    .replace(/\\*(.+?)\\*/g,'<em>$1</em>')
+    .replace(/\\[([^\\]]+)\\]\\(([^)]+)\\)/g,'<a href="$2" target="_blank">$1</a>');
+}
+function isTableRow(s) { return s.trim().startsWith('|') && s.trim().endsWith('|'); }
+function isSepRow(s) { return /^\\|[-|: ]+\\|$/.test(s.trim()); }
+function renderTblRow(s, tag) {
+  return '<tr>' + s.trim().slice(1,-1).split('|').map(function(c) {
+    return '<' + tag + '>' + inlineMd(c.trim()) + '</' + tag + '>';
+  }).join('') + '</tr>';
+}
+function simpleMarkdown(md) {
+  var lines = md.split('\\n'), out = [], inList = false, inTable = false, tblHead = false;
+  var inCode = false, codeLang = '', codeBuf = [];
+  for (var i = 0; i < lines.length; i++) {
+    var raw = lines[i];
+    // fenced code blocks
+    if (inCode) {
+      if (raw.trimEnd() === '\`\`\`' || raw.trimEnd() === '~~~') {
+        out.push('<pre><code' + (codeLang ? ' class="lang-' + esc(codeLang) + '"' : '') + '>' +
+          codeBuf.map(function(l) { return esc(l); }).join('\\n') + '</code></pre>');
+        codeBuf = []; inCode = false; codeLang = '';
+      } else { codeBuf.push(raw); }
+      continue;
+    }
+    var fence = raw.match(/^(\`\`\`|~~~)(\\w*)\\s*$/);
+    if (fence) {
+      if (inList) { out.push('</ul>'); inList = false; }
+      if (inTable) { out.push('</tbody></table>'); inTable = false; }
+      inCode = true; codeLang = fence[2] || ''; continue;
+    }
+    // tables
+    if (isTableRow(raw)) {
+      if (!inTable) {
+        if (inList) { out.push('</ul>'); inList = false; }
+        out.push('<table>'); inTable = true; tblHead = true;
+      }
+      if (isSepRow(raw)) { tblHead = false; out.push('<tbody>'); continue; }
+      if (tblHead) out.push('<thead>' + renderTblRow(raw,'th') + '</thead>');
+      else out.push(renderTblRow(raw,'td'));
+      continue;
+    }
+    if (inTable) { out.push('</tbody></table>'); inTable = false; }
+    if (raw.trim() === '') { if (inList) { out.push('</ul>'); inList = false; } continue; }
+    var hm = raw.match(/^(#{1,6})\\s+(.+)$/);
+    if (hm) { if (inList) { out.push('</ul>'); inList = false; }
+      out.push('<h'+hm[1].length+'>'+inlineMd(hm[2])+'</h'+hm[1].length+'>'); continue; }
+    var bq = raw.match(/^>\\s*(.*)/);
+    if (bq) { if (inList) { out.push('</ul>'); inList = false; }
+      out.push('<blockquote>'+inlineMd(bq[1])+'</blockquote>'); continue; }
+    var li = raw.match(/^[-*+]\\s+(.+)$/);
+    if (li) { if (!inList) { out.push('<ul>'); inList = true; }
+      out.push('<li>'+inlineMd(li[1])+'</li>'); continue; }
+    if (inList) { out.push('</ul>'); inList = false; }
+    if (raw.trim() === '---' || raw.trim() === '***') { out.push('<hr>'); continue; }
+    out.push('<p>'+inlineMd(raw)+'</p>');
+  }
+  if (inList) out.push('</ul>');
+  if (inTable) out.push('</tbody></table>');
+  if (inCode) out.push('<pre><code>' + codeBuf.map(function(l){return esc(l);}).join('\\n') + '</code></pre>');
+  return out.join('\\n');
+}
+
+// \u2500\u2500 Yatt control (per-block independent widget) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+// Called from onclick attributes injected into innerHTML \u2014 must be top-level
+function yattCtrlSetView(ctrlId, panel) {
+  ctrlViews[ctrlId] = panel;
+  var ctrl = document.getElementById(ctrlId);
+  if (!ctrl) return;
+  ctrl.querySelectorAll('.yatt-ctrl-tab').forEach(function(btn) {
+    btn.classList.toggle('active', btn.getAttribute('data-panel') === panel);
+  });
+  ctrl.querySelectorAll('.yatt-ctrl-panel').forEach(function(p) {
+    p.classList.toggle('active', p.getAttribute('data-panel') === panel);
+  });
+}
+
+function buildKanbanHtml(tasks) {
+  var byStatus = {};
+  KANBAN_COLS.forEach(function(s) { byStatus[s] = []; });
+  (tasks || []).forEach(function(t) {
+    var s = t.status || 'new';
+    if (!byStatus[s]) byStatus[s] = [];
+    byStatus[s].push(t);
+  });
+  var html = '';
+  KANBAN_COLS.forEach(function(status) {
+    var cards = byStatus[status] || [];
+    var color = STATUS_COLOR[status] || '#7d8590';
+    var label = STATUS_LABEL[status] || status;
+    var isEmpty = cards.length === 0;
+    html += '<div class="k-col' + (isEmpty ? ' empty' : '') + '" data-status="' + esc(status) + '">';
+    if (isEmpty) {
+      html += '<div class="k-col-empty-label">';
+      html += '<span class="k-col-empty-line" style="background:' + color + '"></span>';
+      html += '<span class="k-col-empty-title" style="color:' + color + '">' + esc(label) + '</span>';
+      html += '</div>';
+    } else {
+      html += '<div class="k-col-header">';
+      html += '<span class="k-col-line" style="background:' + color + '"></span>';
+      html += '<span class="k-col-title">' + esc(label) + '</span>';
+      html += '<span class="k-col-count">' + cards.length + '</span>';
+      html += '</div>';
+    }
+    html += '<div class="k-cards">';
+    cards.forEach(function(t) {
+      var indent = t.depth > 0 ? 'padding-left:' + (8 + t.depth * 10) + 'px;' : '';
+      var lineAttr = t.line ? ' data-line="' + t.line + '"' : '';
+      html += '<div class="k-card" style="' + indent + '"' + lineAttr + '>';
+      html += '<div class="k-card-name">' + esc(t.name) + '</div>';
+      if (t.description) {
+        html += '<div class="k-card-desc">' + esc(t.description) + '</div>';
+      }
+      var sb = shiftBadges(t);
+      if (sb) html += '<div class="k-card-shifts">' + sb + '</div>';
+      html += '<div class="k-card-meta">';
+      if (t.assignees && t.assignees.length) {
+        t.assignees.slice(0,3).forEach(function(a) { html += avatarEl(a, false); });
+      }
+      if (t.priority && t.priority !== 'normal') {
+        html += '<span class="k-priority" data-p="' + esc(t.priority) + '">' + esc(t.priority) + '</span>';
+      }
+      html += '</div>';
+      if (t.progress != null) {
+        html += '<div class="k-progress"><div class="k-progress-fill" style="width:' + t.progress + '%"></div></div>';
+      }
+      html += '</div>';
+    });
+    html += '</div></div>';
+  });
+  if (!html) html = '<div class="loading" style="padding:20px">No tasks.</div>';
+  return html;
+}
+
+function buildPeopleHtml(tasks) {
+  var byPerson = {};
+  (tasks || []).forEach(function(t) {
+    var people = t.assignees && t.assignees.length ? t.assignees : ['(unassigned)'];
+    people.forEach(function(p) {
+      if (!byPerson[p]) byPerson[p] = [];
+      byPerson[p].push(t);
+    });
+  });
+  var names = Object.keys(byPerson).sort(function(a,b) {
+    if (a==='(unassigned)') return 1; if (b==='(unassigned)') return -1;
+    return a.localeCompare(b);
+  });
+  if (!names.length) return '<div class="loading" style="padding:20px">No tasks.</div>';
+  var html = '';
+  names.forEach(function(name) {
+    var list = byPerson[name];
+    var isU = name === '(unassigned)';
+    html += '<div class="person-card"><div class="person-header">';
+    if (!isU) html += avatarEl(name, true);
+    html += '<div><div class="person-name">' + esc(isU ? 'Unassigned' : '@' + name) + '</div>';
+    html += '<div class="person-count">' + list.length + ' task' + (list.length===1?'':'s') + '</div></div></div>';
+    list.forEach(function(t) {
+      var lineAttr = t.line ? ' data-line="' + t.line + '"' : '';
+      html += '<div class="ptask-row"' + lineAttr + '>' + sdot(t.status);
+      html += '<span class="ptask-name">' + esc(t.name) + '</span>';
+      var sb = shiftBadges(t);
+      if (sb) html += sb;
+      if (t.priority && t.priority !== 'normal')
+        html += '<span class="ptask-priority" data-p="' + esc(t.priority) + '">' + esc(t.priority) + '</span>';
+      if (t.progress != null) html += '<span class="ptask-prog">' + t.progress + '%</span>';
+      html += '</div>';
+    });
+    html += '</div>';
+  });
+  return html;
+}
+
+function buildYattCtrlHtml(block, ctrlId, bidx) {
+  var errHtml = block.errors && block.errors.length
+    ? '<div class="yatt-errors">' + block.errors.map(esc).join('<br>') + '</div>' : '';
+  var tl = '<div class="yatt-ctrl-panel active" data-panel="timeline">' + (block.html || '') + '</div>';
+  var kb = '<div class="yatt-ctrl-panel" data-panel="kanban"><div class="ctrl-kanban">' +
+    buildKanbanHtml(block.tasks || []) + '</div></div>';
+  var pe = '<div class="yatt-ctrl-panel" data-panel="people"><div class="ctrl-people">' +
+    buildPeopleHtml(block.tasks || []) + '</div></div>';
+  var md = '<div class="yatt-ctrl-panel" data-panel="markdown">' +
+    '<textarea class="yatt-block-editor" spellcheck="false">' + esc(block.source || '') + '</textarea>' +
+    '<div class="yatt-block-bar"><span class="yatt-block-status"></span></div>' +
+    '</div>';
+  var tabs =
+    '<button class="yatt-ctrl-tab active" data-panel="timeline" onclick="yattCtrlSetView(\\'' + ctrlId + '\\',\\'timeline\\')">Timeline</button>' +
+    '<button class="yatt-ctrl-tab" data-panel="kanban" onclick="yattCtrlSetView(\\'' + ctrlId + '\\',\\'kanban\\')">Kanban</button>' +
+    '<button class="yatt-ctrl-tab" data-panel="people" onclick="yattCtrlSetView(\\'' + ctrlId + '\\',\\'people\\')">People</button>' +
+    '<button class="yatt-ctrl-tab" data-panel="markdown" onclick="yattCtrlSetView(\\'' + ctrlId + '\\',\\'markdown\\')">Edit</button>';
+  return '<div class="yatt-ctrl" id="' + ctrlId + '" data-bidx="' + bidx + '">' +
+    errHtml +
+    '<div class="yatt-ctrl-bar">' + tabs + '</div>' +
+    '<div class="yatt-ctrl-body">' + tl + kb + pe + md + '</div>' +
+    '</div>';
+}
+
+// \u2500\u2500 Document view \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+function renderViewPanel() {
+  var el = document.getElementById('doc-content');
+  if (!el) return;
+  if (state.blocks) { buildDocument(state.blocks, el); return; }
+  el.innerHTML = '<div class="loading">Loading\u2026</div>';
+  fetch('/api/render?p=' + encodeURIComponent(state.currentFile))
+    .then(function(r) { return r.json(); })
+    .then(function(d) { state.blocks = d.blocks || []; buildDocument(state.blocks, el); })
+    .catch(function(e) { el.innerHTML = '<div class="loading err">' + esc(e.message) + '</div>'; });
+}
+
+function buildDocument(blocks, container) {
+  if (!blocks || !blocks.length) {
+    container.innerHTML = '<div class="loading">No content.</div>'; return;
+  }
+  var html = '', ctrlIdx = 0, ctrlList = [];
+  blocks.forEach(function(b) {
+    if (b.kind === 'heading') {
+      html += '<div class="block-h' + b.level + '">' + inlineMd(b.text) + '</div>';
+    } else if (b.kind === 'prose') {
+      html += '<div class="prose">' + simpleMarkdown(b.text) + '</div>';
+    } else if (b.kind === 'yatt') {
+      var bidx = ctrlIdx++;
+      html += buildYattCtrlHtml(b, 'yatt-' + bidx, bidx);
+      ctrlList.push(bidx);
+    }
+  });
+  container.innerHTML = html;
+  ctrlList.forEach(function(bidx) {
+    var ctrlId = 'yatt-' + bidx;
+    initYattCtrl(ctrlId, bidx);
+    var saved = ctrlViews[ctrlId];
+    if (saved && saved !== 'timeline') yattCtrlSetView(ctrlId, saved);
+  });
+}
+
+// \u2500\u2500 Markdown/edit view \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+function renderMarkdownView() {
+  var ta = document.getElementById('editor');
+  if (!ta) return;
+  if (state.source !== null) { ta.value = state.source; return; }
+  fetch('/api/source?p=' + encodeURIComponent(state.currentFile))
+    .then(function(r) { return r.text(); })
+    .then(function(src) { state.source = src; ta.value = src; })
+    .catch(function(e) { ta.value = '// Error: ' + e.message; });
+}
+
+function doSave() {
+  if (!state.currentFile) return;
+  var ta = document.getElementById('editor');
+  if (!ta) return;
+  var src = ta.value; state.source = src;
+  setSaveStatus('unsaved', 'Saving\u2026');
+  fetch('/api/save?p=' + encodeURIComponent(state.currentFile), {
+    method: 'POST', headers: { 'Content-Type': 'text/plain; charset=utf-8' }, body: src
+  })
+    .then(function(r) {
+      if (r.ok) setSaveStatus('saved', 'Saved');
+      else r.json().then(function(d) { setSaveStatus('error', d.error || ('HTTP ' + r.status)); });
+    })
+    .catch(function(e) { setSaveStatus('error', e.message); });
+}
+
+function setSaveStatus(cls, text) {
+  var el = document.getElementById('save-status');
+  if (!el) return;
+  el.className = cls; el.textContent = text;
+  if (cls === 'saved') setTimeout(function() {
+    if (el.textContent === 'Saved') { el.textContent = ''; el.className = ''; }
+  }, 2500);
+}
+
+// \u2500\u2500 Page-level view switching \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+function setView(v) {
+  if (state.saveTimer && v !== 'markdown') {
+    clearTimeout(state.saveTimer); state.saveTimer = null; doSave();
+  }
+  state.view = v;
+  var url = new URL(window.location.href);
+  url.searchParams.set('v', v);
+  history.replaceState(history.state, '', url.toString());
+  document.querySelectorAll('.tab').forEach(function(btn) {
+    btn.classList.toggle('active', btn.getAttribute('data-view') === v);
+  });
+  ['view','markdown'].forEach(function(n) {
+    var el = document.getElementById('view-' + n);
+    if (el) el.hidden = (n !== v);
+  });
+  renderCurrentView();
+}
+
+function renderCurrentView() {
+  if (!state.currentFile) return;
+  if (state.view === 'view') renderViewPanel();
+  else if (state.view === 'markdown') renderMarkdownView();
+}
+
+// \u2500\u2500 Sidebar \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+function buildSidebar(files) {
+  state.files = files;
+  var groups = {};
+  files.forEach(function(f) {
+    var parts = f.split('/');
+    var dir = parts.length > 1 ? parts.slice(0,-1).join('/') : '';
+    if (!groups[dir]) groups[dir] = [];
+    groups[dir].push(f);
+  });
+  var keys = Object.keys(groups).sort(function(a,b) {
+    if (a==='') return -1; if (b==='') return 1; return a.localeCompare(b);
+  });
+  var html = '';
+  keys.forEach(function(dir) {
+    html += '<div class="group-label">' + esc(dir===''?'(root)':dir+'/') + '</div>';
+    groups[dir].forEach(function(f) {
+      var name = f.split('/').pop();
+      html += '<a class="file-item' + (f===state.currentFile?' active':'') + '" data-p="' + esc(f) + '" title="' + esc(f) + '">' + esc(name) + '</a>';
+    });
+  });
+  document.getElementById('sidebar-inner').innerHTML = html;
+  var fc = document.getElementById('file-count');
+  if (fc) fc.textContent = files.length + ' file' + (files.length===1?'':'s');
+  document.querySelectorAll('.file-item').forEach(function(el) {
+    el.addEventListener('click', function() { navigateTo(el.getAttribute('data-p')); });
+  });
+}
+
+// \u2500\u2500 Navigation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+function loadFile(p) {
+  state.currentFile = p; state.blocks = null; state.source = null;
+  document.querySelectorAll('.file-item').forEach(function(el) {
+    el.classList.toggle('active', el.getAttribute('data-p') === p);
+  });
+  renderCurrentView();
+}
+
+function loadFileList() {
+  return fetch('/api/files')
+    .then(function(r) { return r.json(); })
+    .then(function(files) { buildSidebar(files); return files; });
+}
+
+function navigateTo(p) {
+  var u = new URL(window.location.href);
+  u.searchParams.set('p', p);
+  history.pushState({ p: p }, '', u.toString());
+  loadFile(p);
+}
+
+// \u2500\u2500 SSE live reload \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+function connectSse() {
+  var es = new EventSource('/events');
+  var debounce = null;
+  es.onmessage = function(e) {
+    if (e.data === 'reload') {
+      clearTimeout(debounce);
+      debounce = setTimeout(function() {
+        loadFileList().then(function() {
+          if (state.view === 'markdown') return;
+          if (state.currentFile) { state.blocks = null; renderCurrentView(); }
+        });
+      }, 250);
+    }
+  };
+  es.onerror = function() { es.close(); setTimeout(connectSse, 2000); };
+}
+
+// \u2500\u2500 Init \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+window.addEventListener('DOMContentLoaded', function() {
+  var fp = document.getElementById('folder-path');
+  if (fp && typeof ROOT_FOLDER !== 'undefined') fp.textContent = ROOT_FOLDER;
+
+  document.querySelectorAll('.tab').forEach(function(btn) {
+    btn.addEventListener('click', function() { setView(btn.getAttribute('data-view')); });
+  });
+
+  var editor = document.getElementById('editor');
+  if (editor) {
+    editor.addEventListener('input', function() {
+      state.source = editor.value;
+      if (state.saveTimer) clearTimeout(state.saveTimer);
+      setSaveStatus('unsaved', 'Unsaved');
+      state.saveTimer = setTimeout(function() { state.saveTimer = null; doSave(); }, 1200);
+    });
+  }
+
+  var params = new URLSearchParams(window.location.search);
+  var initial = params.get('p');
+  var initialView = params.get('v') || 'view';
+
+  state.view = initialView;
+  document.querySelectorAll('.tab').forEach(function(btn) {
+    btn.classList.toggle('active', btn.getAttribute('data-view') === initialView);
+  });
+  ['view','markdown'].forEach(function(n) {
+    var el = document.getElementById('view-' + n);
+    if (el) el.hidden = (n !== initialView);
+  });
+
+  // Task edit overlay: close on backdrop click or Escape
+  var overlay = document.getElementById('task-edit-overlay');
+  if (overlay) {
+    overlay.addEventListener('click', function(e) {
+      if (e.target === overlay) closeTaskEdit();
+    });
+  }
+  document.addEventListener('keydown', function(e) {
+    if (e.key === 'Escape') closeTaskEdit();
+  });
+
+  // Popup form: submit on Enter in inputs (not textarea)
+  document.addEventListener('keydown', function(e) {
+    if (e.key === 'Enter' && state.editTask) {
+      var tag = (e.target && e.target.tagName) ? e.target.tagName.toLowerCase() : '';
+      if (tag === 'input' || tag === 'select') { e.preventDefault(); saveTaskEdit(); }
+    }
+  });
+
+  loadFileList().then(function(files) {
+    if (initial && files.includes(initial)) loadFile(initial);
+    else if (files.length > 0) navigateTo(files[0]);
+    else {
+      var c = document.getElementById('doc-content');
+      if (c) c.innerHTML = '<div class="loading">No .md files found.</div>';
+    }
+  });
+
+  connectSse();
+});
+
+window.addEventListener('popstate', function(e) {
+  if (e.state && e.state.p) loadFile(e.state.p);
+});
+
+// \u2500\u2500 Git integration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+var gitState = { available: false, dirty: false, ahead: 0, behind: 0, branch: '', hasRemote: false };
+var gitBusy = false;
+
+function refreshGitStatus() {
+  fetch('/api/git/status').then(function(r){ return r.json(); }).then(function(s) {
+    gitState = s;
+    renderGitWidget();
+  }).catch(function(){});
+}
+
+function renderGitWidget() {
+  var w = document.getElementById('git-widget');
+  if (!w) return;
+  if (!gitState.available) { w.classList.add('hidden'); return; }
+  w.classList.remove('hidden');
+
+  document.getElementById('git-dot').className = 'git-dot' + (gitState.dirty ? ' dirty' : '');
+  document.getElementById('git-branch-name').textContent = gitState.branch;
+
+  var behindEl = document.getElementById('git-behind');
+  var aheadEl  = document.getElementById('git-ahead');
+  if (gitState.behind > 0) {
+    document.getElementById('git-behind-n').textContent = gitState.behind;
+    behindEl.classList.remove('hidden');
+  } else { behindEl.classList.add('hidden'); }
+  if (gitState.ahead > 0) {
+    document.getElementById('git-ahead-n').textContent = gitState.ahead;
+    aheadEl.classList.remove('hidden');
+  } else { aheadEl.classList.add('hidden'); }
+
+  document.getElementById('git-pull-btn').style.display = gitState.hasRemote ? '' : 'none';
+  document.getElementById('git-push-btn').style.display = gitState.hasRemote ? '' : 'none';
+  document.getElementById('git-commit-btn').disabled = gitBusy;
+  document.getElementById('git-pull-btn').disabled  = gitBusy;
+  document.getElementById('git-push-btn').disabled  = gitBusy;
+}
+
+function setGitMsg(msg, type) {
+  var el = document.getElementById('git-msg');
+  el.textContent = msg;
+  el.className = type === 'ok' ? 'ok' : type === 'err' ? 'err' : '';
+  if (msg && type !== 'err') setTimeout(function(){ if (el.textContent === msg) el.textContent = ''; }, 4000);
+}
+
+function gitDoPull() {
+  if (gitBusy) return;
+  gitBusy = true; renderGitWidget(); setGitMsg('Pulling\u2026', '');
+  fetch('/api/git/pull', { method: 'POST' }).then(function(r){ return r.json(); }).then(function(r) {
+    gitBusy = false;
+    if (r.conflict) { setGitMsg('Merge conflict \u2014 resolve from CLI', 'err'); }
+    else if (!r.ok)  { setGitMsg('Pull failed \u2014 ' + (r.output || r.error || '').slice(0, 60), 'err'); }
+    else             { setGitMsg('Pulled \u2713', 'ok'); }
+    refreshGitStatus();
+  }).catch(function(e){ gitBusy = false; setGitMsg('Pull error', 'err'); refreshGitStatus(); });
+}
+
+function gitDoPush() {
+  if (gitBusy) return;
+  gitBusy = true; renderGitWidget(); setGitMsg('Pushing\u2026', '');
+  fetch('/api/git/push', { method: 'POST' }).then(function(r){ return r.json(); }).then(function(r) {
+    gitBusy = false;
+    if (r.rejected) { setGitMsg('Push rejected \u2014 pull first or use CLI', 'err'); }
+    else if (!r.ok) { setGitMsg('Push failed \u2014 ' + (r.output || r.error || '').slice(0, 60), 'err'); }
+    else            { setGitMsg('Pushed \u2713', 'ok'); }
+    refreshGitStatus();
+  }).catch(function(e){ gitBusy = false; setGitMsg('Push error', 'err'); refreshGitStatus(); });
+}
+
+function openCommitModal() {
+  var now = new Date();
+  var ts = now.getFullYear() + '-' +
+    String(now.getMonth()+1).padStart(2,'0') + '-' +
+    String(now.getDate()).padStart(2,'0') + ' ' +
+    String(now.getHours()).padStart(2,'0') + ':' +
+    String(now.getMinutes()).padStart(2,'0');
+  document.getElementById('git-commit-msg').value = 'Update tasks ' + ts;
+  document.getElementById('git-commit-modal').classList.remove('hidden');
+  setTimeout(function(){ document.getElementById('git-commit-msg').focus(); }, 50);
+}
+
+function closeCommitModal() {
+  document.getElementById('git-commit-modal').classList.add('hidden');
+}
+
+function gitDoCommit() {
+  var msg = document.getElementById('git-commit-msg').value.trim();
+  if (!msg) return;
+  closeCommitModal();
+  gitBusy = true; renderGitWidget(); setGitMsg('Committing\u2026', '');
+  fetch('/api/git/commit', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ message: msg })
+  }).then(function(r){ return r.json(); }).then(function(r) {
+    gitBusy = false;
+    if (r.noop)     { setGitMsg('Nothing to commit', ''); }
+    else if (!r.ok) { setGitMsg('Commit failed \u2014 ' + (r.error || r.output || '').slice(0, 60), 'err'); }
+    else            { setGitMsg('Committed \u2713', 'ok'); }
+    refreshGitStatus();
+  }).catch(function(e){ gitBusy = false; setGitMsg('Commit error', 'err'); refreshGitStatus(); });
+}
+
+// Initial status fetch + poll every 30s
+refreshGitStatus();
+setInterval(refreshGitStatus, 30000);
+`;
+function buildShellHtml(rootDir) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>YATT Viewer</title>
+<style>${CSS}</style>
+</head>
+<body>
+<div id="app">
+  <header id="topbar">
+    <span class="logo">YATT</span>
+    <span id="folder-path"></span>
+    <div id="view-tabs">
+      <button class="tab active" data-view="view">View</button>
+      <button class="tab" data-view="markdown">Markdown</button>
+    </div>
+    <span id="save-status"></span>
+    <span id="file-count" style="font-size:11px;color:var(--muted);flex-shrink:0"></span>
+    <div id="git-widget" class="hidden">
+      <span id="git-msg"></span>
+      <span class="git-count behind hidden" id="git-behind" title="commits behind remote">\u2193<span id="git-behind-n"></span></span>
+      <span class="git-branch"><span class="git-dot" id="git-dot"></span><span id="git-branch-name"></span></span>
+      <span class="git-count ahead hidden" id="git-ahead" title="commits ahead of remote">\u2191<span id="git-ahead-n"></span></span>
+      <button class="git-btn" id="git-pull-btn" onclick="gitDoPull()" title="Pull latest from remote">Pull</button>
+      <button class="git-btn primary" id="git-commit-btn" onclick="openCommitModal()" title="Commit all changes">Commit</button>
+      <button class="git-btn" id="git-push-btn" onclick="gitDoPush()" title="Push to remote">Push</button>
+    </div>
+  </header>
+  <div id="workspace">
+    <nav id="sidebar"><div id="sidebar-inner"></div></nav>
+    <main id="main">
+      <div id="view-view" class="view-panel"><div id="doc-content"></div></div>
+      <div id="view-markdown" class="view-panel" hidden><textarea id="editor" spellcheck="false"></textarea></div>
+    </main>
+  </div>
+</div>
+
+<div id="git-commit-modal" class="hidden">
+  <div id="git-commit-box">
+    <h3>Commit changes</h3>
+    <textarea id="git-commit-msg" placeholder="Commit message"></textarea>
+    <div class="git-commit-actions">
+      <button class="te-btn te-btn-ghost" onclick="closeCommitModal()">Cancel</button>
+      <button class="te-btn te-btn-primary" onclick="gitDoCommit()">Commit</button>
+    </div>
+  </div>
+</div>
+<div id="gantt-hover-card"></div>
+<div id="task-edit-overlay" class="hidden">
+  <div id="task-edit-modal">
+    <div class="te-title">Edit Task</div>
+    <div class="te-row">
+      <div class="te-field"><label>Name</label><input type="text" id="te-name" placeholder="Task name"></div>
+    </div>
+    <div class="te-row cols-2">
+      <div class="te-field"><label>Status</label>
+        <select id="te-status">
+          <option value="new">New</option>
+          <option value="active">Active</option>
+          <option value="review">Review</option>
+          <option value="blocked">Blocked</option>
+          <option value="paused">Paused</option>
+          <option value="done">Done</option>
+          <option value="cancelled">Cancelled</option>
+        </select>
+      </div>
+      <div class="te-field"><label>Priority</label>
+        <select id="te-priority">
+          <option value="low">Low</option>
+          <option value="normal">Normal</option>
+          <option value="high">High</option>
+          <option value="critical">Critical</option>
+        </select>
+      </div>
+    </div>
+    <div class="te-row cols-2">
+      <div class="te-field"><label>Assignees (space-separated)</label><input type="text" id="te-assignees" placeholder="@alice @bob"></div>
+      <div class="te-field"><label>Tags (space-separated)</label><input type="text" id="te-tags" placeholder="#backend #api"></div>
+    </div>
+    <div class="te-row cols-3">
+      <div class="te-field"><label>Duration</label><input type="text" id="te-duration" placeholder="5d, 2bd, 1w"></div>
+      <div class="te-field"><label>Start Date</label><input type="text" id="te-startdate" placeholder="YYYY-MM-DD"></div>
+      <div class="te-field"><label>Due Date</label><input type="text" id="te-duedate" placeholder="YYYY-MM-DD"></div>
+    </div>
+    <div class="te-row cols-3">
+      <div class="te-field"><label>Progress (%)</label><input type="number" id="te-progress" min="0" max="100" placeholder="0"></div>
+      <div class="te-field"><label>ID</label><input type="text" id="te-id" placeholder="task-slug"></div>
+      <div class="te-field"><label>After (deps)</label><input type="text" id="te-after" placeholder="id1,id2"></div>
+    </div>
+    <div class="te-row cols-2">
+      <div class="te-field"><label>Delayed by</label><input type="text" id="te-delayed" placeholder="e.g. 3d, 1w"></div>
+      <div class="te-field"><label>Blocked for</label><input type="text" id="te-blocked" placeholder="e.g. 2w, 5d"></div>
+    </div>
+    <div class="te-row">
+      <div class="te-field"><label>Description</label><textarea id="te-description" placeholder="Optional description (saved as // comment lines below the task)"></textarea></div>
+    </div>
+    <div class="te-actions">
+      <span class="te-save-msg" id="te-save-msg"></span>
+      <button class="te-btn te-btn-ghost" onclick="closeTaskEdit()">Cancel</button>
+      <button class="te-btn te-btn-primary" onclick="saveTaskEdit()">Save</button>
+    </div>
+  </div>
+</div>
+<script>var ROOT_FOLDER = ${JSON.stringify(rootDir)};
+${JS}</script>
+</body>
+</html>`;
+}
+function createServer2(rootDir, port, sse) {
+  const shellHtml = buildShellHtml(rootDir);
+  return http.createServer((req, res) => {
+    const parsed = new URL(req.url ?? "/", `http://localhost:${port}`);
+    const pathname = parsed.pathname;
+    if (pathname === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(shellHtml);
+      return;
+    }
+    if (pathname === "/api/files") {
+      const files = walkMdFiles(rootDir).map((f) => path.relative(rootDir, f).split(path.sep).join("/"));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(files));
+      return;
+    }
+    if (pathname === "/api/render") {
+      const absPath = guardPath(rootDir, parsed.searchParams.get("p"));
+      if (!absPath) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end('"Bad request"');
+        return;
+      }
+      try {
+        const blocks = renderFile(absPath);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ blocks }));
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+      return;
+    }
+    if (pathname === "/api/source") {
+      const absPath = guardPath(rootDir, parsed.searchParams.get("p"));
+      if (!absPath) {
+        res.writeHead(400);
+        res.end("Bad request");
+        return;
+      }
+      try {
+        res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end(fs.readFileSync(absPath, "utf8"));
+      } catch (e) {
+        res.writeHead(500);
+        res.end(e.message);
+      }
+      return;
+    }
+    if (pathname === "/api/save" && req.method === "POST") {
+      const absPath = guardPath(rootDir, parsed.searchParams.get("p"));
+      if (!absPath) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end('"Bad request"');
+        return;
+      }
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => {
+        try {
+          fs.writeFileSync(absPath, Buffer.concat(chunks).toString("utf8"), "utf8");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end('"ok"');
+          sse.broadcast("reload");
+        } catch (e) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+      req.on("error", (e) => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      });
+      return;
+    }
+    if (pathname === "/api/save-block" && req.method === "POST") {
+      const absPath = guardPath(rootDir, parsed.searchParams.get("p"));
+      const blockIdx = parseInt(parsed.searchParams.get("idx") ?? "-1", 10);
+      if (!absPath || blockIdx < 0) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Bad request" }));
+        return;
+      }
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => {
+        try {
+          const newBlockSource = Buffer.concat(chunks).toString("utf8");
+          const fileSource = fs.readFileSync(absPath, "utf8");
+          const updated = replaceYattBlock(fileSource, blockIdx, newBlockSource);
+          fs.writeFileSync(absPath, updated, "utf8");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end('"ok"');
+          sse.broadcast("reload");
+        } catch (e) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+      req.on("error", (e) => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      });
+      return;
+    }
+    if (pathname === "/events") {
+      sse.add(res);
+      return;
+    }
+    if (pathname === "/api/git/status" && req.method === "GET") {
+      gitStatus(rootDir).then((status) => {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(status));
+      }).catch((e) => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      });
+      return;
+    }
+    if (pathname === "/api/git/pull" && req.method === "POST") {
+      runGit(["pull"], rootDir).then((r) => {
+        const conflict = r.stdout.includes("CONFLICT") || r.stderr.includes("CONFLICT");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: r.ok && !conflict, conflict, output: r.stdout || r.stderr }));
+        if (r.ok && !conflict) sse.broadcast("reload");
+      }).catch((e) => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      });
+      return;
+    }
+    if (pathname === "/api/git/commit" && req.method === "POST") {
+      const chunks = [];
+      req.on("data", (c) => chunks.push(c));
+      req.on("end", () => {
+        let msg = "Update tasks";
+        try {
+          msg = JSON.parse(Buffer.concat(chunks).toString()).message || msg;
+        } catch {
+        }
+        runGit(["add", "-A"], rootDir).then((a) => {
+          if (!a.ok) throw new Error(a.stderr || "git add failed");
+          return runGit(["commit", "-m", msg], rootDir);
+        }).then((r) => {
+          const noop = r.stdout.includes("nothing to commit");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: r.ok || noop, noop, output: r.stdout || r.stderr }));
+        }).catch((e) => {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: e.message }));
+        });
+      });
+      return;
+    }
+    if (pathname === "/api/git/push" && req.method === "POST") {
+      runGit(["push"], rootDir).then((r) => {
+        const rejected = r.stderr.includes("rejected") || r.stderr.includes("[rejected]");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: r.ok && !rejected, rejected, output: r.stdout || r.stderr }));
+      }).catch((e) => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      });
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found");
+  });
+}
+function runGit(args, cwd) {
+  return new Promise((resolve2) => {
+    execFile("git", args, { cwd, timeout: 15e3 }, (err, stdout, stderr) => {
+      resolve2({ ok: !err, stdout: stdout.trim(), stderr: stderr.trim() });
+    });
+  });
+}
+async function gitStatus(cwd) {
+  const fallback = { available: false, dirty: false, ahead: 0, behind: 0, branch: "", hasRemote: false };
+  const branchR = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  if (!branchR.ok) return fallback;
+  const branch = branchR.stdout || "HEAD";
+  const porcelain = await runGit(["status", "--porcelain"], cwd);
+  if (!porcelain.ok) return fallback;
+  const dirty = porcelain.stdout.length > 0;
+  const remoteR = await runGit(["rev-parse", "--abbrev-ref", "@{u}"], cwd);
+  const hasRemote = remoteR.ok;
+  let ahead = 0, behind = 0;
+  if (hasRemote) {
+    const countR = await runGit(["rev-list", "--left-right", "--count", "HEAD...@{u}"], cwd);
+    if (countR.ok) {
+      const parts = countR.stdout.split(/\s+/);
+      ahead = parseInt(parts[0] ?? "0", 10) || 0;
+      behind = parseInt(parts[1] ?? "0", 10) || 0;
+    }
+  }
+  return { available: true, dirty, ahead, behind, branch, hasRemote };
+}
+function isPortFree(port) {
+  return new Promise((resolve2) => {
+    const srv = http.createServer();
+    srv.once("error", () => resolve2(false));
+    srv.once("listening", () => {
+      srv.close();
+      resolve2(true);
+    });
+    srv.listen(port, "127.0.0.1");
+  });
+}
+async function findFreePort(start) {
+  for (let p = start; p < start + 20; p++) {
+    if (await isPortFree(p)) return p;
+  }
+  return start;
+}
+var { folder, port: preferredPort, noOpen } = parseArgs(process.argv.slice(2));
+if (!fs.existsSync(folder)) {
+  process.stderr.write(`Error: folder not found: ${folder}
+`);
+  process.exit(1);
+}
+(async () => {
+  const port = await findFreePort(preferredPort);
+  const addr = `http://localhost:${port}`;
+  if (port !== preferredPort) {
+    process.stdout.write(`Port ${preferredPort} in use, using ${port} instead.
+`);
+  }
+  const sse = new SseManager();
+  watchFolder(folder, sse);
+  const server = createServer2(folder, port, sse);
+  server.listen(port, "127.0.0.1", () => {
+    process.stdout.write(`
+YATT  \xB7  ${folder}
+`);
+    process.stdout.write(`
+  \u2192 ${addr}
+
+`);
+    process.stdout.write(`Ctrl+C to stop.
+
+`);
+    if (!noOpen) openBrowser(addr);
+  });
+  server.on("error", (err) => {
+    process.stderr.write(`Server error: ${err.message}
+`);
+    process.exit(1);
+  });
+})();