@estruyf/worklog-cli 0.0.0-stage → 0.2.0

package/dist/worklog.js

@@ -0,0 +1,2909 @@
+#!/usr/bin/env node
+
+// cli/worklog.ts
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { parseArgs } from "node:util";
+
+// src/db/memoryDb.ts
+var MemoryDb = class {
+  clients = [];
+  tasks = [];
+  worklog = [];
+  dayNotes = [];
+  checklists = [];
+  meetings = [];
+  tasksById = /* @__PURE__ */ new Map();
+  notesByDate = /* @__PURE__ */ new Map();
+  /** Replace all cached records (called by the indexer after a full parse). */
+  load(data) {
+    this.clients = [...data.clients].sort((a, b) => a.name.localeCompare(b.name));
+    this.tasks = data.tasks.filter((t) => t.id);
+    this.worklog = data.worklog;
+    this.dayNotes = data.dayNotes;
+    this.checklists = data.checklists;
+    this.meetings = data.meetings;
+    this.tasksById = new Map(this.tasks.map((t) => [t.id, t]));
+    this.notesByDate = new Map(this.dayNotes.map((n) => [n.date, n]));
+  }
+  reset() {
+    this.load({ clients: [], tasks: [], worklog: [], dayNotes: [], checklists: [], meetings: [] });
+  }
+  getClients() {
+    return this.clients;
+  }
+  getTask(id) {
+    return this.tasksById.get(id);
+  }
+  /** Direct children of a task. */
+  getChildren(parentId) {
+    return this.tasks.filter((t) => t.parentId === parentId).sort(byCreatedThenTitle);
+  }
+  /** Active (not-yet-closed) tasks for a client — closed once it has a completed date. */
+  openTasksForClient(clientId) {
+    return this.tasks.filter((t) => t.clientIds.includes(clientId) && !t.completed).sort(byCreatedThenTitle);
+  }
+  /** Archived occurrences of a recurring task, most recently completed first. */
+  occurrencesOf(templateId) {
+    return this.tasks.filter((t) => t.repeatOf === templateId).sort((a, b) => (b.completed ?? "").localeCompare(a.completed ?? ""));
+  }
+  /** Every task (open + done) — used to build the app state. */
+  getAllTasks() {
+    return [...this.tasks].sort(byCreatedThenTitle);
+  }
+  /** Every worklog entry — used to build the app state. */
+  getAllWorklog() {
+    return [...this.worklog].sort((a, b) => a.date.localeCompare(b.date) || a.clientId.localeCompare(b.clientId));
+  }
+  /** The note for one day, if it has one. */
+  getDayNote(date) {
+    return this.notesByDate.get(date);
+  }
+  /** Every day note, oldest first — used to build the app state. */
+  getAllDayNotes() {
+    return [...this.dayNotes].sort((a, b) => a.date.localeCompare(b.date));
+  }
+  /** Every checklist, by name — the order they are offered in. */
+  getAllChecklists() {
+    return [...this.checklists].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  getMeeting(id) {
+    return this.meetings.find((m) => m.id === id);
+  }
+  /** Every meeting, most recent first — the order every list of them is read in. */
+  getAllMeetings() {
+    return [...this.meetings].sort(
+      (a, b) => b.date.localeCompare(a.date) || (b.time ?? "").localeCompare(a.time ?? "") || a.title.localeCompare(b.title)
+    );
+  }
+};
+function byCreatedThenTitle(a, b) {
+  return (a.created ?? "").localeCompare(b.created ?? "") || a.title.localeCompare(b.title);
+}
+
+// src/parser/taskHeading.ts
+var H2 = /^##\s+/;
+var META = /^-\s+[A-Za-z][\w-]*\s*:/;
+var ID_META = /^-\s+id\s*:\s*(.+?)\s*$/;
+function isTaskHeading(lines, index) {
+  if (!H2.test(lines[index])) {
+    return false;
+  }
+  for (let i = index + 1; i < lines.length; i++) {
+    if (ID_META.test(lines[i])) {
+      return true;
+    }
+    if (!META.test(lines[i])) {
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/util/date.ts
+function today() {
+  return toISODate(/* @__PURE__ */ new Date());
+}
+function toISODate(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function monthOf(isoDate) {
+  return isoDate.slice(0, 7);
+}
+function nowStamp() {
+  const d = /* @__PURE__ */ new Date();
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  return `${toISODate(d)} ${hh}:${mm}`;
+}
+function parseISODate(iso) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(iso.trim());
+  if (!match) {
+    return void 0;
+  }
+  const y = Number(match[1]);
+  const m = Number(match[2]);
+  const d = Number(match[3]);
+  if (m < 1 || m > 12 || d < 1 || d > daysInMonth(y, m)) {
+    return void 0;
+  }
+  return { y, m, d };
+}
+function isValidISODate(iso) {
+  return parseISODate(iso) !== void 0;
+}
+function formatParts(p) {
+  return `${String(p.y).padStart(4, "0")}-${String(p.m).padStart(2, "0")}-${String(p.d).padStart(2, "0")}`;
+}
+function daysInMonth(y, m) {
+  return new Date(Date.UTC(y, m, 0)).getUTCDate();
+}
+function weekdayOf(iso) {
+  const p = parseISODate(iso);
+  if (!p) {
+    return 0;
+  }
+  return new Date(Date.UTC(p.y, p.m - 1, p.d)).getUTCDay();
+}
+function daysSinceEpoch(iso) {
+  const p = parseISODate(iso);
+  if (!p) {
+    return 0;
+  }
+  return Math.round(Date.UTC(p.y, p.m - 1, p.d) / 864e5);
+}
+function addDays(iso, n) {
+  const p = parseISODate(iso);
+  if (!p) {
+    return iso;
+  }
+  const d = new Date(Date.UTC(p.y, p.m - 1, p.d + n));
+  return formatParts({ y: d.getUTCFullYear(), m: d.getUTCMonth() + 1, d: d.getUTCDate() });
+}
+function addMonths(iso, n) {
+  const p = parseISODate(iso);
+  if (!p) {
+    return iso;
+  }
+  const total = p.y * 12 + (p.m - 1) + n;
+  const y = Math.floor(total / 12);
+  const m = total % 12 + 1;
+  return formatParts({ y, m, d: Math.min(p.d, daysInMonth(y, m)) });
+}
+function addYears(iso, n) {
+  return addMonths(iso, n * 12);
+}
+function withDayOfMonth(iso, day) {
+  const p = parseISODate(iso);
+  if (!p) {
+    return iso;
+  }
+  const max = daysInMonth(p.y, p.m);
+  return formatParts({ y: p.y, m: p.m, d: day === "last" ? max : Math.min(day, max) });
+}
+function weekIndexOf(iso) {
+  return Math.floor((daysSinceEpoch(iso) + 4) / 7);
+}
+
+// src/model/recurrence.ts
+var WEEKDAY_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+var WEEKDAY_ALIASES = {
+  sun: 0,
+  sunday: 0,
+  mon: 1,
+  monday: 1,
+  tue: 2,
+  tues: 2,
+  tuesday: 2,
+  wed: 3,
+  weds: 3,
+  wednesday: 3,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  thursday: 4,
+  fri: 5,
+  friday: 5,
+  sat: 6,
+  saturday: 6
+};
+var BUSINESS_DAYS = [1, 2, 3, 4, 5];
+var MAX_STEPS = 800;
+var HEAD_SUGAR = {
+  daily: { unit: "day", interval: 1 },
+  weekly: { unit: "week", interval: 1 },
+  monthly: { unit: "month", interval: 1 },
+  yearly: { unit: "year", interval: 1 },
+  annually: { unit: "year", interval: 1 },
+  weekdays: { unit: "week", interval: 1, weekdays: BUSINESS_DAYS }
+};
+var UNIT_WORDS = {
+  day: "day",
+  days: "day",
+  week: "week",
+  weeks: "week",
+  month: "month",
+  months: "month",
+  year: "year",
+  years: "year"
+};
+function parseRecurrence(input) {
+  const text = input.trim().toLowerCase();
+  if (!text) {
+    return void 0;
+  }
+  const [headText, specText] = splitOn(text);
+  const head = parseHead(headText);
+  if (!head) {
+    return void 0;
+  }
+  const rec = {
+    unit: head.unit,
+    interval: head.interval,
+    weekdays: head.weekdays,
+    anchor: "schedule"
+  };
+  if (specText !== void 0) {
+    if (!applySpec(rec, specText)) {
+      return void 0;
+    }
+  }
+  return rec;
+}
+function splitOn(text) {
+  const m = /^(.*?)\s+on\s+(.+)$/.exec(text);
+  return m ? [m[1].trim(), m[2].trim()] : [text, void 0];
+}
+function parseHead(text) {
+  const sugar = HEAD_SUGAR[text];
+  if (sugar) {
+    return { ...sugar };
+  }
+  const m = /^every\s+(?:(\d+)\s+)?([a-z]+)$/.exec(text);
+  if (!m) {
+    return void 0;
+  }
+  const unit = UNIT_WORDS[m[2]];
+  if (!unit) {
+    return void 0;
+  }
+  const interval = m[1] === void 0 ? 1 : Number(m[1]);
+  if (!Number.isInteger(interval) || interval < 1 || interval > 1e3) {
+    return void 0;
+  }
+  return { unit, interval };
+}
+function applySpec(rec, spec) {
+  switch (rec.unit) {
+    case "week": {
+      const days = spec.split(/[\s,]+/).filter(Boolean).map((name) => WEEKDAY_ALIASES[name]);
+      if (!days.length || days.some((d) => d === void 0)) {
+        return false;
+      }
+      rec.weekdays = [...new Set(days)].sort((a, b) => a - b);
+      return true;
+    }
+    case "month": {
+      const day = parseMonthDay(spec);
+      if (day === void 0) {
+        return false;
+      }
+      rec.monthDay = day;
+      return true;
+    }
+    case "year": {
+      const m = /^(\d{1,2})-(\d{1,2}|last)$/.exec(spec);
+      if (!m) {
+        return false;
+      }
+      const month = Number(m[1]);
+      const day = parseMonthDay(m[2]);
+      if (month < 1 || month > 12 || day === void 0) {
+        return false;
+      }
+      rec.month = month;
+      rec.monthDay = day;
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+function parseMonthDay(spec) {
+  if (spec === "last") {
+    return "last";
+  }
+  if (!/^\d{1,2}$/.test(spec)) {
+    return void 0;
+  }
+  const n = Number(spec);
+  return n >= 1 && n <= 31 ? n : void 0;
+}
+function formatRecurrence(rec) {
+  const head = formatHead(rec);
+  const spec = formatSpec(rec);
+  return spec ? `${head} on ${spec}` : head;
+}
+function formatHead(rec) {
+  if (rec.interval === 1) {
+    if (rec.unit === "week" && isBusinessWeek(rec.weekdays)) {
+      return "weekdays";
+    }
+    return { day: "daily", week: "weekly", month: "monthly", year: "yearly" }[rec.unit];
+  }
+  return `every ${rec.interval} ${rec.unit}s`;
+}
+function formatSpec(rec) {
+  switch (rec.unit) {
+    case "week":
+      if (!rec.weekdays?.length || rec.interval === 1 && isBusinessWeek(rec.weekdays)) {
+        return void 0;
+      }
+      return rec.weekdays.map((d) => WEEKDAY_NAMES[d]).join(",");
+    case "month":
+      return rec.monthDay === void 0 ? void 0 : String(rec.monthDay);
+    case "year":
+      if (rec.month === void 0 || rec.monthDay === void 0) {
+        return void 0;
+      }
+      return `${String(rec.month).padStart(2, "0")}-${rec.monthDay === "last" ? "last" : String(rec.monthDay).padStart(2, "0")}`;
+    default:
+      return void 0;
+  }
+}
+function isBusinessWeek(weekdays) {
+  return !!weekdays && weekdays.length === 5 && BUSINESS_DAYS.every((d) => weekdays.includes(d));
+}
+function nextOccurrence(rec, base) {
+  if (!isValidISODate(base)) {
+    return void 0;
+  }
+  const next = rec.anchor === "completion" ? stepFromCompletion(rec, base) : stepInSeries(rec, base);
+  if (!next) {
+    return void 0;
+  }
+  if (rec.until && next > rec.until) {
+    return void 0;
+  }
+  return next;
+}
+function firstOccurrence(rec, from) {
+  if (!isValidISODate(from)) {
+    return void 0;
+  }
+  const namesDays = !!rec.weekdays?.length || rec.monthDay !== void 0 || rec.month !== void 0;
+  const start = namesDays ? nextOccurrence({ ...rec, interval: 1, anchor: "schedule", until: void 0 }, addDays(from, -1)) : from;
+  if (!start || rec.until && start > rec.until) {
+    return void 0;
+  }
+  return start;
+}
+function nextDueAfterCompletion(rec, currentDue, completedDate) {
+  const base = rec.anchor === "completion" ? completedDate : currentDue ?? completedDate;
+  return nextOccurrence(rec, base);
+}
+function stepFromCompletion(rec, base) {
+  let next;
+  switch (rec.unit) {
+    case "day":
+      next = addDays(base, rec.interval);
+      break;
+    case "week":
+      next = addDays(base, 7 * rec.interval);
+      break;
+    case "month":
+      next = addMonths(base, rec.interval);
+      break;
+    case "year":
+      next = addYears(base, rec.interval);
+      break;
+  }
+  if (rec.monthDay !== void 0) {
+    next = withDayOfMonth(next, rec.monthDay);
+  }
+  if (rec.weekdays?.length) {
+    next = rollToWeekday(next, rec.weekdays);
+  }
+  return next > base ? next : void 0;
+}
+function stepInSeries(rec, base) {
+  switch (rec.unit) {
+    case "day":
+      return addDays(base, rec.interval);
+    case "week":
+      return nextWeekly(rec, base);
+    case "month":
+      return nextMonthly(rec, base);
+    case "year":
+      return nextYearly(rec, base);
+  }
+}
+function nextWeekly(rec, base) {
+  if (!rec.weekdays?.length) {
+    return addDays(base, 7 * rec.interval);
+  }
+  const baseWeek = weekIndexOf(base);
+  for (let i = 1; i <= MAX_STEPS; i++) {
+    const cand = addDays(base, i);
+    if (!rec.weekdays.includes(weekdayOf(cand))) {
+      continue;
+    }
+    if ((weekIndexOf(cand) - baseWeek) % rec.interval === 0) {
+      return cand;
+    }
+  }
+  return void 0;
+}
+function nextMonthly(rec, base) {
+  const parts = parseISODate(base);
+  if (!parts) {
+    return void 0;
+  }
+  const day = rec.monthDay ?? parts.d;
+  const firstOfMonth = withDayOfMonth(base, 1);
+  for (let k = 0; k <= MAX_STEPS; k++) {
+    const cand = withDayOfMonth(addMonths(firstOfMonth, k * rec.interval), day);
+    if (cand > base) {
+      return cand;
+    }
+  }
+  return void 0;
+}
+function nextYearly(rec, base) {
+  const parts = parseISODate(base);
+  if (!parts) {
+    return void 0;
+  }
+  const month = rec.month ?? parts.m;
+  const day = rec.monthDay ?? parts.d;
+  for (let k = 0; k <= MAX_STEPS; k++) {
+    const year = parts.y + k * rec.interval;
+    const cand = withDayOfMonth(`${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-01`, day);
+    if (cand > base) {
+      return cand;
+    }
+  }
+  return void 0;
+}
+function rollToWeekday(iso, weekdays) {
+  for (let i = 0; i < 7; i++) {
+    const cand = addDays(iso, i);
+    if (weekdays.includes(weekdayOf(cand))) {
+      return cand;
+    }
+  }
+  return iso;
+}
+
+// src/parser/taskParser.ts
+var H1 = /^#\s+(.*)$/;
+var H22 = /^##\s+(.*)$/;
+var META2 = /^-\s+([A-Za-z][\w-]*)\s*:\s*(.*)$/;
+var NOTES_HEADING = /^###\s+Notes\s*$/;
+var NOTE_ENTRY = /^-\s+(\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2})?)\s+—\s+(.*)$/;
+var PROMPTS_HEADING = /^###\s+Prompts\s*$/;
+var PROMPT_ENTRY = /^-\s+\[([ xX])\]\s*(.*)$/;
+var PROMPT_RAN = /^(\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2})?)\s+—\s+(.*)$/;
+var CHECKLIST_HEADING = /^###\s+Checklist\s*$/;
+var CHECKLIST_ENTRY = /^-\s+\[([ xX])\]\s*(.*)$/;
+function parseTaskFile(content, sourceFile, clientId) {
+  const lines = content.split(/\r?\n/);
+  const result = { tasks: [] };
+  let current;
+  let inMeta = false;
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const t = current.task;
+    const { description, checklist, prompts, notes } = splitBody(current.descLines);
+    result.tasks.push({
+      id: t.id ?? "",
+      title: (t.title ?? "").trim(),
+      description,
+      status: t.status ?? "open",
+      priority: t.priority,
+      parentId: t.parentId,
+      clientIds: t.clientIds && t.clientIds.length ? t.clientIds : [clientId],
+      links: t.links,
+      attachments: t.attachments,
+      created: t.created,
+      due: t.due,
+      completed: t.completed,
+      repeat: buildRecurrence(t.repeatMeta),
+      lastDone: t.lastDone,
+      repeatOf: t.repeatOf,
+      workedOn: t.workedOn,
+      tags: t.tags,
+      checklist,
+      prompts,
+      notes,
+      sourceFile,
+      sourceLine: current.line
+    });
+    current = void 0;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const h2 = isTaskHeading(lines, i) ? H22.exec(line) : null;
+    if (h2) {
+      flush();
+      current = {
+        task: { title: h2[1], links: [], clientIds: [] },
+        descLines: [],
+        line: i
+      };
+      inMeta = true;
+      continue;
+    }
+    if (!current) {
+      const h1 = H1.exec(line);
+      if (h1 && result.displayName === void 0) {
+        result.displayName = h1[1].trim();
+      }
+      continue;
+    }
+    if (inMeta) {
+      const meta = META2.exec(line);
+      if (meta) {
+        applyMeta(current.task, meta[1].toLowerCase(), meta[2].trim());
+        continue;
+      }
+      inMeta = false;
+      if (line.trim() === "") {
+        continue;
+      }
+    }
+    current.descLines.push(line);
+  }
+  flush();
+  return result;
+}
+function buildRecurrence(meta) {
+  if (!meta?.expr) {
+    return void 0;
+  }
+  const rec = parseRecurrence(meta.expr);
+  if (!rec) {
+    return void 0;
+  }
+  const anchor = parseAnchor(meta.from);
+  if (anchor) {
+    rec.anchor = anchor;
+  }
+  if (meta.until) {
+    rec.until = meta.until;
+  }
+  return rec;
+}
+function parseAnchor(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "completion":
+    case "completed":
+    case "done":
+      return "completion";
+    case "schedule":
+    case "due":
+      return "schedule";
+    default:
+      return void 0;
+  }
+}
+function repeatMeta(task) {
+  return task.repeatMeta ??= {};
+}
+function applyMeta(task, key, value) {
+  switch (key) {
+    case "id":
+      task.id = value;
+      break;
+    case "status":
+      task.status = value || "open";
+      break;
+    case "priority":
+      task.priority = value || void 0;
+      break;
+    case "parent":
+      task.parentId = value || void 0;
+      break;
+    case "link": {
+      const link = parseLink(value);
+      if (link) {
+        task.links.push(link);
+      }
+      break;
+    }
+    case "attachment":
+      if (value) {
+        (task.attachments ??= []).push(value);
+      }
+      break;
+    case "created":
+      task.created = value || void 0;
+      break;
+    case "due":
+      task.due = value || void 0;
+      break;
+    case "completed":
+      task.completed = value || void 0;
+      break;
+    case "repeat":
+      repeatMeta(task).expr = value || void 0;
+      break;
+    case "repeatfrom":
+      repeatMeta(task).from = value || void 0;
+      break;
+    case "repeatuntil":
+      repeatMeta(task).until = value || void 0;
+      break;
+    case "lastdone":
+      task.lastDone = value || void 0;
+      break;
+    case "repeatof":
+      task.repeatOf = value || void 0;
+      break;
+    case "tags": {
+      const tags = value.split(/[,\s]+/).map((t) => t.trim()).filter(Boolean);
+      task.tags = tags.length ? tags : void 0;
+      break;
+    }
+    case "worked": {
+      if (!value) {
+        break;
+      }
+      const dates = value.split(/[\s,]+/).map((d) => d.trim()).filter(Boolean);
+      if (dates.length === 0) {
+        break;
+      }
+      const all = /* @__PURE__ */ new Set([...task.workedOn ?? [], ...dates]);
+      task.workedOn = [...all].sort();
+      break;
+    }
+    case "client":
+      task.clientIds = value.split(/[,\s]+/).filter(Boolean);
+      break;
+    default:
+      break;
+  }
+}
+function parseLink(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const spaceIdx = trimmed.search(/\s/);
+  if (spaceIdx === -1) {
+    return { url: trimmed };
+  }
+  return {
+    url: trimmed.slice(0, spaceIdx),
+    label: trimmed.slice(spaceIdx + 1).trim() || void 0
+  };
+}
+function splitBody(lines) {
+  const marks = [];
+  lines.forEach((line, at) => {
+    if (PROMPTS_HEADING.test(line)) {
+      marks.push({ at, kind: "prompts" });
+    } else if (NOTES_HEADING.test(line)) {
+      marks.push({ at, kind: "notes" });
+    } else if (CHECKLIST_HEADING.test(line)) {
+      marks.push({ at, kind: "checklist" });
+    }
+  });
+  if (marks.length === 0) {
+    const description2 = lines.join("\n").trim();
+    return { description: description2 || void 0 };
+  }
+  const description = lines.slice(0, marks[0].at).join("\n").trim();
+  const checklist = [];
+  const prompts = [];
+  const notes = [];
+  marks.forEach((mark, i) => {
+    const body = lines.slice(mark.at + 1, marks[i + 1]?.at ?? lines.length);
+    if (mark.kind === "prompts") {
+      prompts.push(...parsePrompts(body));
+    } else if (mark.kind === "checklist") {
+      checklist.push(...parseChecklist(body));
+    } else {
+      notes.push(...parseNotes(body));
+    }
+  });
+  return {
+    description: description || void 0,
+    checklist: checklist.length ? checklist : void 0,
+    prompts: prompts.length ? prompts : void 0,
+    notes: notes.length ? notes : void 0
+  };
+}
+function parseChecklist(lines) {
+  const items = [];
+  for (const line of lines) {
+    const m = CHECKLIST_ENTRY.exec(line);
+    const text = m?.[2].trim();
+    if (m && text) {
+      items.push({ text, done: m[1].toLowerCase() === "x" });
+    }
+  }
+  return items;
+}
+function parsePrompts(lines) {
+  const prompts = [];
+  let current;
+  const flush = () => {
+    if (current) {
+      prompts.push({
+        title: current.title.trim(),
+        text: current.text.join("\n").trim(),
+        ran: current.ran || void 0,
+        ranAt: current.ranAt
+      });
+      current = void 0;
+    }
+  };
+  for (const line of lines) {
+    const m = PROMPT_ENTRY.exec(line);
+    if (m) {
+      flush();
+      const ran = m[1].toLowerCase() === "x";
+      const stamped = ran ? PROMPT_RAN.exec(m[2]) : null;
+      current = {
+        title: stamped ? stamped[2] : m[2],
+        ran,
+        ranAt: stamped ? stamped[1].replace("T", " ") : void 0,
+        text: []
+      };
+    } else if (current) {
+      current.text.push(line.replace(/^ {1,2}/, ""));
+    }
+  }
+  flush();
+  return prompts;
+}
+function parseNotes(lines) {
+  const notes = [];
+  let current;
+  const flush = () => {
+    if (current) {
+      notes.push({
+        timestamp: current.timestamp,
+        text: current.text.join("\n").trim()
+      });
+      current = void 0;
+    }
+  };
+  for (const line of lines) {
+    const m = NOTE_ENTRY.exec(line);
+    if (m) {
+      flush();
+      current = { timestamp: m[1].replace("T", " "), text: [m[2]] };
+    } else if (current) {
+      current.text.push(line.replace(/^ {1,2}/, ""));
+    }
+  }
+  flush();
+  return notes;
+}
+function serializePrompt(prompt) {
+  const stamp = prompt.ran && prompt.ranAt ? `${prompt.ranAt} \u2014 ` : "";
+  const head = `- [${prompt.ran ? "x" : " "}] ${stamp}${prompt.title}`;
+  if (!prompt.text.trim()) {
+    return head;
+  }
+  const body = prompt.text.split(/\r?\n/).map((l) => l.trim() ? `  ${l}` : "");
+  return [head, ...body].join("\n");
+}
+function serializeChecklistItem(item) {
+  return `- [${item.done ? "x" : " "}] ${item.text}`;
+}
+function serializeNote(note) {
+  const [first = "", ...rest] = note.text.split(/\r?\n/);
+  const head = `- ${note.timestamp} \u2014 ${first}`;
+  const cont = rest.map((l) => l.trim() ? `  ${l}` : "");
+  return [head, ...cont].join("\n");
+}
+function serializeTask(task, clientId) {
+  const out = [];
+  out.push(`## ${task.title}`);
+  out.push(`- id: ${task.id}`);
+  out.push(`- status: ${task.status}`);
+  if (task.priority) {
+    out.push(`- priority: ${task.priority}`);
+  }
+  if (task.parentId) {
+    out.push(`- parent: ${task.parentId}`);
+  }
+  if (clientId && (task.clientIds.length > 1 || task.clientIds.length === 1 && task.clientIds[0] !== clientId)) {
+    out.push(`- client: ${task.clientIds.join(" ")}`);
+  }
+  for (const link of task.links) {
+    out.push(`- link: ${link.label ? `${link.url} ${link.label}` : link.url}`);
+  }
+  for (const ref of task.attachments ?? []) {
+    out.push(`- attachment: ${ref}`);
+  }
+  if (task.created) {
+    out.push(`- created: ${task.created}`);
+  }
+  if (task.due) {
+    out.push(`- due: ${task.due}`);
+  }
+  if (task.completed) {
+    out.push(`- completed: ${task.completed}`);
+  }
+  if (task.repeat) {
+    out.push(`- repeat: ${formatRecurrence(task.repeat)}`);
+    if (task.repeat.anchor === "completion") {
+      out.push(`- repeatFrom: completion`);
+    }
+    if (task.repeat.until) {
+      out.push(`- repeatUntil: ${task.repeat.until}`);
+    }
+  }
+  if (task.lastDone) {
+    out.push(`- lastDone: ${task.lastDone}`);
+  }
+  if (task.repeatOf) {
+    out.push(`- repeatOf: ${task.repeatOf}`);
+  }
+  for (const worked of task.workedOn ?? []) {
+    out.push(`- worked: ${worked}`);
+  }
+  if (task.tags && task.tags.length) {
+    out.push(`- tags: ${task.tags.join(", ")}`);
+  }
+  const body = [];
+  if (task.description && task.description.trim()) {
+    body.push(task.description.trim());
+  }
+  if (task.checklist && task.checklist.length) {
+    body.push(["### Checklist", ...task.checklist.map(serializeChecklistItem)].join("\n"));
+  }
+  if (task.prompts && task.prompts.length) {
+    body.push(`### Prompts
+${task.prompts.map(serializePrompt).join("\n\n")}`);
+  }
+  if (task.notes && task.notes.length) {
+    body.push(["### Notes", ...task.notes.map(serializeNote)].join("\n"));
+  }
+  if (body.length) {
+    out.push("");
+    out.push(body.join("\n\n"));
+  }
+  return out.join("\n");
+}
+
+// src/parser/worklogParser.ts
+var LINE = /^-\s+(\d{4}-\d{2}-\d{2})\s+(\S+)\s+([\d.]+)\s*(?:[—–]|-{1,2}|:)?\s*(.*)$/;
+function parseWorklogFile(content, sourceFile) {
+  const lines = content.split(/\r?\n/);
+  const entries = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = LINE.exec(lines[i].trim());
+    if (!m) {
+      continue;
+    }
+    const hours = Number(m[3]);
+    if (!isFinite(hours)) {
+      continue;
+    }
+    const note = m[4]?.trim();
+    entries.push({
+      date: m[1],
+      clientId: m[2],
+      hours,
+      note: note ? note : void 0,
+      sourceFile,
+      sourceLine: i
+    });
+  }
+  return entries;
+}
+function serializeWorklogEntry(entry) {
+  const base = `- ${entry.date} ${entry.clientId} ${formatHours(entry.hours)}`;
+  return entry.note ? `${base} \u2014 ${entry.note}` : base;
+}
+function formatHours(hours) {
+  return Number.isInteger(hours) ? String(hours) : String(hours);
+}
+
+// src/parser/dayNotes.ts
+var DAY_HEADING = /^##[ \t]+(\d{4}-\d{2}-\d{2})[ \t]*$/;
+function splitDayNoteBlocks(content) {
+  const lines = content.split(/\r?\n/);
+  const starts = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (DAY_HEADING.test(lines[i])) {
+      starts.push(i);
+    }
+  }
+  const header = lines.slice(0, starts.length ? starts[0] : lines.length).join("\n").replace(/\s+$/, "");
+  const blocks = [];
+  for (let b = 0; b < starts.length; b++) {
+    const end = b + 1 < starts.length ? starts[b + 1] : lines.length;
+    const date = DAY_HEADING.exec(lines[starts[b]])[1];
+    blocks.push({ date, text: bodyOf(lines.slice(starts[b] + 1, end)), line: starts[b] });
+  }
+  return { header, blocks };
+}
+function parseDayNotesFile(content, sourceFile) {
+  const byDate = /* @__PURE__ */ new Map();
+  for (const b of splitDayNoteBlocks(content).blocks) {
+    if (b.text !== "") {
+      byDate.set(b.date, { date: b.date, body: b.text, sourceFile, sourceLine: b.line });
+    }
+  }
+  return [...byDate.values()];
+}
+function bodyOf(lines) {
+  let start = 0;
+  while (start < lines.length && lines[start].trim() === "") {
+    start++;
+  }
+  return lines.slice(start).join("\n").replace(/\s+$/, "");
+}
+
+// src/parser/checklistParser.ts
+var ITEM = /^(\s*)([-*+])\s+\[([ xX])\]\s?(.*)$/;
+var H12 = /^#[ \t]+(.*)$/;
+var H23 = /^##[ \t]+(.*)$/;
+var LAST_RUN = /^-[ \t]+last run:[ \t]*(\d{4}-\d{2}-\d{2})[ \t]*$/;
+function parseChecklistFile(content, sourceFile, id) {
+  const lines = content.split(/\r?\n/);
+  let name = "";
+  let lastRun;
+  const sections = [{ items: [] }];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const item = ITEM.exec(line);
+    if (item) {
+      sections[sections.length - 1].items.push({
+        text: item[4].trim(),
+        done: item[3] !== " ",
+        line: i
+      });
+      continue;
+    }
+    const h2 = H23.exec(line);
+    if (h2) {
+      sections.push({ title: h2[1].trim(), line: i, items: [] });
+      continue;
+    }
+    const h1 = H12.exec(line);
+    if (h1 && !name) {
+      name = h1[1].trim();
+      continue;
+    }
+    const run2 = LAST_RUN.exec(line);
+    if (run2 && !lastRun) {
+      lastRun = run2[1];
+    }
+  }
+  const kept = sections.filter((s, i) => i > 0 || s.items.length > 0);
+  return {
+    id,
+    name: name || id,
+    lastRun,
+    sections: kept.length ? kept : [sections[0]],
+    sourceFile
+  };
+}
+
+// src/parser/blocks.ts
+var ID_META2 = /^-\s+id\s*:\s*(.+?)\s*$/;
+function findBlockRange(content, taskId) {
+  const lines = content.split(/\r?\n/);
+  let blockStart = -1;
+  let matched = false;
+  const ranges = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (isTaskHeading(lines, i)) {
+      if (blockStart !== -1) {
+        ranges.push({ start: blockStart, end: i, matched });
+      }
+      blockStart = i;
+      matched = false;
+    } else if (blockStart !== -1) {
+      const m = ID_META2.exec(lines[i]);
+      if (m && m[1] === taskId) {
+        matched = true;
+      }
+    }
+  }
+  if (blockStart !== -1) {
+    ranges.push({ start: blockStart, end: lines.length, matched });
+  }
+  const hit = ranges.find((r) => r.matched);
+  return hit ? { start: hit.start, end: hit.end } : void 0;
+}
+function replaceBlock(content, taskId, newBlock) {
+  const range = findBlockRange(content, taskId);
+  if (!range) {
+    return void 0;
+  }
+  const lines = content.split(/\r?\n/);
+  const original = lines.slice(range.start, range.end);
+  const hadTrailingBlank = original.length > 0 && original[original.length - 1].trim() === "";
+  const replacement = newBlock.split(/\r?\n/);
+  if (hadTrailingBlank) {
+    replacement.push("");
+  }
+  const next = [...lines.slice(0, range.start), ...replacement, ...lines.slice(range.end)];
+  return next.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function extractBlock(content, taskId) {
+  const range = findBlockRange(content, taskId);
+  if (!range) {
+    return void 0;
+  }
+  const lines = content.split(/\r?\n/);
+  const blockLines = lines.slice(range.start, range.end);
+  while (blockLines.length && blockLines[blockLines.length - 1].trim() === "") {
+    blockLines.pop();
+  }
+  const before = lines.slice(0, range.start);
+  const after = lines.slice(range.end);
+  while (before.length && before[before.length - 1].trim() === "") {
+    before.pop();
+  }
+  const remainderLines = [...before];
+  if (before.length && after.some((l) => l.trim() !== "")) {
+    remainderLines.push("");
+  }
+  remainderLines.push(...after);
+  let remainder = remainderLines.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "");
+  if (remainder) {
+    remainder += "\n";
+  }
+  return { block: blockLines.join("\n"), remainder, startLine: range.start };
+}
+
+// src/parser/meetingParser.ts
+var H24 = /^##\s+(.*)$/;
+var META3 = /^-\s+([A-Za-z][\w-]*)\s*:\s*(.*)$/;
+var ACTIONS_HEADING = /^###\s+Action items\s*$/i;
+var ACTION_ENTRY = /^-\s+\[([ xX])\]\s*(.*)$/;
+var ACTION_TASK = /^(.*?)\s+→\s+(t_[A-Za-z0-9]+)$/;
+var TIME = /^(\d{1,2}):(\d{2})$/;
+var DURATION = /^(?:(\d+(?:\.\d+)?)\s*h)?\s*(?:(\d+)\s*m(?:in)?)?$/i;
+function parseDuration(value) {
+  const text = value.trim();
+  if (/^\d+$/.test(text)) {
+    const n = Number(text);
+    return n > 0 ? n : void 0;
+  }
+  const m = DURATION.exec(text);
+  if (!m || !m[1] && !m[2]) {
+    return void 0;
+  }
+  const minutes = Math.round(Number(m[1] ?? 0) * 60 + Number(m[2] ?? 0));
+  return minutes > 0 ? minutes : void 0;
+}
+function normalizeTime(value) {
+  const m = TIME.exec(value.trim());
+  if (!m || Number(m[1]) > 23 || Number(m[2]) > 59) {
+    return void 0;
+  }
+  return `${m[1].padStart(2, "0")}:${m[2]}`;
+}
+function parseMeetingFile(content, sourceFile) {
+  const lines = content.split(/\r?\n/);
+  const starts = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (isTaskHeading(lines, i)) {
+      starts.push(i);
+    }
+  }
+  const meetings = [];
+  for (let b = 0; b < starts.length; b++) {
+    const end = b + 1 < starts.length ? starts[b + 1] : lines.length;
+    const meeting = parseBlock(lines.slice(starts[b], end), sourceFile, starts[b]);
+    if (meeting.id) {
+      meetings.push(meeting);
+    }
+  }
+  return meetings;
+}
+function parseBlock(lines, sourceFile, line) {
+  const meeting = {
+    id: "",
+    title: (H24.exec(lines[0])?.[1] ?? "").trim(),
+    date: "",
+    people: [],
+    notes: "",
+    actions: [],
+    sourceFile,
+    sourceLine: line
+  };
+  let i = 1;
+  for (; i < lines.length; i++) {
+    const meta = META3.exec(lines[i]);
+    if (!meta) {
+      break;
+    }
+    const value = meta[2].trim();
+    switch (meta[1].toLowerCase()) {
+      case "id":
+        meeting.id = value;
+        break;
+      case "date":
+        meeting.date = value;
+        break;
+      case "time":
+        meeting.time = normalizeTime(value) ?? meeting.time;
+        break;
+      case "duration":
+        meeting.duration = parseDuration(value) ?? meeting.duration;
+        break;
+      case "client":
+        meeting.clientId = value || void 0;
+        break;
+      case "people":
+        meeting.people = splitPeople(value);
+        break;
+    }
+  }
+  const body = trimBlank(lines.slice(i));
+  const at = actionsStart(body);
+  if (at < 0) {
+    meeting.notes = body.join("\n");
+  } else {
+    meeting.notes = trimBlank(body.slice(0, at)).join("\n");
+    meeting.actions = body.slice(at + 1).filter((l) => l.trim() !== "").map(parseAction);
+  }
+  return meeting;
+}
+function actionsStart(body) {
+  for (let i = body.length - 1; i >= 0; i--) {
+    if (ACTIONS_HEADING.test(body[i])) {
+      return body.slice(i + 1).every((l) => l.trim() === "" || ACTION_ENTRY.test(l)) ? i : -1;
+    }
+  }
+  return -1;
+}
+function parseAction(line) {
+  const m = ACTION_ENTRY.exec(line);
+  const done = m[1] !== " ";
+  const linked = ACTION_TASK.exec(m[2].trim());
+  return linked ? { text: linked[1].trim(), done, taskId: linked[2] } : { text: m[2].trim(), done };
+}
+function splitPeople(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of value.split(",")) {
+    const name = raw.trim();
+    if (name && !seen.has(name.toLowerCase())) {
+      seen.add(name.toLowerCase());
+      out.push(name);
+    }
+  }
+  return out;
+}
+function trimBlank(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start].trim() === "") {
+    start++;
+  }
+  while (end > start && lines[end - 1].trim() === "") {
+    end--;
+  }
+  return lines.slice(start, end);
+}
+
+// src/model/status.ts
+var DEFAULT_STATUSES = [
+  { id: "open", label: "Open" },
+  { id: "in-progress", label: "In progress" },
+  { id: "done", label: "Closed", terminal: true }
+];
+var MAX_STATUS_LABEL = 20;
+var HEX_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+function parseStatusColor(color) {
+  const value = typeof color === "string" ? color.trim() : "";
+  return HEX_COLOR.test(value) ? value : void 0;
+}
+function normalizeStatuses(input) {
+  const defs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of Array.isArray(input) ? input : []) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const candidate = raw;
+    const id = typeof candidate.id === "string" ? candidate.id.trim() : "";
+    const label2 = typeof candidate.label === "string" ? candidate.label.trim() : "";
+    if (!id || !label2 || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    defs.push({
+      id,
+      label: label2.slice(0, MAX_STATUS_LABEL),
+      terminal: candidate.terminal === true || void 0,
+      color: parseStatusColor(candidate.color)
+    });
+  }
+  if (defs.length === 0) {
+    return DEFAULT_STATUSES.map((s) => ({ ...s }));
+  }
+  const flagged = defs.findIndex((s) => s.terminal);
+  const terminalIndex = flagged >= 0 ? flagged : defs.length - 1;
+  const terminal = defs[terminalIndex];
+  const working = defs.filter((_, i) => i !== terminalIndex);
+  if (working.length === 0) {
+    const fallback = DEFAULT_STATUSES.find((s) => !s.terminal && s.id !== terminal.id) ?? { id: "open", label: "Open" };
+    working.push({ id: fallback.id, label: fallback.label });
+  }
+  return [
+    ...working.map((s) => ({ ...s, terminal: void 0 })),
+    { ...terminal, terminal: true }
+  ];
+}
+function terminalStatusId(statuses) {
+  return (statuses.find((s) => s.terminal) ?? statuses[statuses.length - 1])?.id ?? "done";
+}
+function isTerminalStatus(statuses, id) {
+  return statuses.find((s) => s.id === id)?.terminal === true;
+}
+function openStatusId(statuses) {
+  return (statuses.find((s) => !s.terminal) ?? statuses[0])?.id ?? "open";
+}
+function inProgressStatusId(statuses) {
+  const explicit = statuses.find((s) => s.id === "in-progress");
+  if (explicit) {
+    return explicit.id;
+  }
+  return statuses.filter((s) => !s.terminal)[1]?.id;
+}
+
+// src/model/aiAgents.ts
+var COMMAND_EXECUTOR_ID = "eliostruyf.execcommand";
+var COMMAND_EXECUTOR_URL = `https://marketplace.visualstudio.com/items?itemName=${COMMAND_EXECUTOR_ID}`;
+var AI_AGENTS = [
+  {
+    id: "copilot",
+    label: "GitHub Copilot",
+    description: "Opens Copilot Chat in VS Code with the task in the input box.",
+    command: "workbench.action.chat.open",
+    // `isPartialQuery` is what leaves the prompt sitting in the input rather than
+    // sending it. Without it the link decides what the agent works on; with it,
+    // you do.
+    args: (prompt) => [{ query: prompt, isPartialQuery: true }]
+  },
+  // Appended rather than slotted in, for the same reason as AUTO_SYNC_EVENTS:
+  // `parseAiAgents` orders a saved array by this list, so inserting in the middle
+  // rewrites every existing config on its next save for no reason.
+  {
+    id: "claude",
+    label: "Claude Code",
+    description: "Opens a Claude Code tab in VS Code with the task in its prompt box.",
+    command: "claude-vscode.editor.open",
+    // `(sessionId, prompt, viewColumn)`. The first parameter is left out on
+    // purpose: it resumes an existing session, and passing anything there would
+    // have the prompt read as a session key. The third picks a column, which is a
+    // choice the editor makes better than we can.
+    //
+    // The prompt lands in the tab's input rather than being sent — the webview
+    // reads it once and calls `setInputText`. That is the same bargain as
+    // Copilot's `isPartialQuery`, and the reason this beats the terminal command,
+    // which would run what it was handed.
+    args: (prompt) => [void 0, prompt]
+  }
+];
+function parseAiAgents(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const wanted = new Set(value);
+  return AI_AGENTS.filter((a) => wanted.has(a.id)).map((a) => a.id);
+}
+
+// src/model/syncEvents.ts
+var AUTO_SYNC_EVENTS = [
+  {
+    id: "taskCreated",
+    label: "A task or to-do is created",
+    description: "A new task, subtask or general to-do."
+  },
+  {
+    id: "taskStatus",
+    label: "A task changes state",
+    description: "Status changed, marked done or worked on, reopened, completion date changed."
+  },
+  {
+    id: "taskEdited",
+    label: "A task is edited or deleted",
+    description: "Title, due date, links, tags, description, task notes, checklist, attachments, recurrence, parent \u2014 or a deletion."
+  },
+  {
+    id: "timeLogged",
+    label: "Time is logged",
+    description: "An entry in the day view\u2019s log form is added, changed or removed."
+  },
+  {
+    id: "settings",
+    label: "Clients, statuses or settings change",
+    description: "A client or task status is added, edited, reordered or removed, or these settings are saved."
+  },
+  // Appended, not slotted in beside the other edit events: `parseAutoSyncEvents`
+  // orders a saved array by this list, so an insertion in the middle rewrites
+  // every existing config's `events` on its next save for no reason.
+  {
+    id: "dayNote",
+    label: "A day note is saved",
+    description: "The freeform Markdown written on a day, saved or cleared from the day view."
+  },
+  // Its own event rather than part of `taskEdited`: a prompt queue is an optional
+  // block (`features.prompts`), and someone who writes prompts for an agent
+  // running elsewhere wants them on the branch sooner than the rest of the task.
+  {
+    id: "prompt",
+    label: "A prompt is written or run",
+    description: "A prompt in a task\u2019s queue is added, edited, ticked off as run, or removed."
+  },
+  // Appended for the reason above. Its own event rather than part of any of the
+  // task ones: a list is not a task, and the thing you want on the branch fast is
+  // a list being ticked through on a phone that is about to lose signal.
+  {
+    id: "list",
+    label: "A list changes",
+    description: "An item on a reusable checklist is ticked, added, edited, moved or removed \u2014 or a list is created, renamed, duplicated, deleted or started again."
+  },
+  // Appended for the reason above. Its own event: the notes of a meeting that
+  // just ended are what you want on the branch before the laptop lid closes.
+  {
+    id: "meeting",
+    label: "Meeting notes change",
+    description: "A meeting is started, edited or deleted \u2014 its notes, people, action items or times."
+  }
+];
+function parseAutoSyncEvents(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const wanted = new Set(value);
+  return AUTO_SYNC_EVENTS.filter((e) => wanted.has(e.id)).map((e) => e.id);
+}
+
+// src/model/taskSort.ts
+var TASK_SORT_KEYS = ["created", "due", "priority", "title", "status"];
+var DEFAULT_TASK_SORT = { key: "created", dir: "asc" };
+function normalizeTaskSort(value) {
+  if (!value || typeof value !== "object") {
+    return { ...DEFAULT_TASK_SORT };
+  }
+  const candidate = value;
+  return {
+    key: TASK_SORT_KEYS.includes(candidate.key) ? candidate.key : DEFAULT_TASK_SORT.key,
+    dir: candidate.dir === "desc" ? "desc" : "asc"
+  };
+}
+
+// src/model/codeTheme.ts
+var CODE_THEMES = ["system", "light", "dark"];
+var DEFAULT_CODE_THEME = "system";
+function normalizeCodeTheme(value) {
+  return CODE_THEMES.includes(value) ? value : DEFAULT_CODE_THEME;
+}
+
+// src/workspace/paths.ts
+var DEFAULT_HOURS_PER_DAY = 8;
+var DEFAULT_WEEK_START = 0;
+var DEFAULT_TODOS_PER_PAGE = 5;
+var DEFAULT_AUTO_SYNC = { enabled: false, delayMinutes: 5, events: [] };
+var DEFAULT_FEATURES = { attachments: true, prompts: true, checklist: true, lists: true, meetings: true };
+function parseFeatures(value) {
+  const raw = value ?? {};
+  return {
+    attachments: raw.attachments !== false,
+    prompts: raw.prompts !== false,
+    checklist: raw.checklist !== false,
+    lists: raw.lists !== false,
+    meetings: raw.meetings !== false
+  };
+}
+function parseTodosPerPage(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : DEFAULT_TODOS_PER_PAGE;
+}
+function parseAutoSync(value) {
+  const raw = value ?? {};
+  const delay = typeof raw.delayMinutes === "number" && Number.isFinite(raw.delayMinutes) && raw.delayMinutes >= 1 ? raw.delayMinutes : DEFAULT_AUTO_SYNC.delayMinutes;
+  return { enabled: raw.enabled === true, delayMinutes: delay, events: parseAutoSyncEvents(raw.events) };
+}
+function parseLinks(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((l) => typeof l === "string" ? { url: l } : l).filter((l) => !!l && typeof l.url === "string" && !!l.url.trim()).map((l) => {
+    const label2 = typeof l.label === "string" ? l.label.trim() : "";
+    return { url: l.url.trim(), ...label2 ? { label: label2 } : {} };
+  });
+}
+function parseClientLinks(value) {
+  const links = parseLinks(value);
+  return links.length ? links : void 0;
+}
+var DAY_NAMES = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+function parseWeekStart(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 6) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const idx = DAY_NAMES.indexOf(value.trim().toLowerCase());
+    if (idx >= 0) {
+      return idx;
+    }
+  }
+  return DEFAULT_WEEK_START;
+}
+var FileMap = class {
+  /** repo-relative path -> UTF-8 text (markdown, json). */
+  text = /* @__PURE__ */ new Map();
+  /** repo-relative path -> bytes (images under assets/). */
+  binary = /* @__PURE__ */ new Map();
+  /** Paths written since load; the host commits exactly these. */
+  dirty = /* @__PURE__ */ new Set();
+  /** Dirty paths that were removed rather than written; they commit as tree
+   *  deletions instead of blobs. */
+  deleted = /* @__PURE__ */ new Set();
+  /** Paths the branch is known to hold — everything loaded, plus everything a
+   *  successful sync wrote. A delete only has to reach GitHub for those. */
+  remote = /* @__PURE__ */ new Set();
+  /** Blob SHA per path as loaded from GitHub, to skip unchanged files on reload. */
+  baseSha = /* @__PURE__ */ new Map();
+  /** Text of each path as the branch last had it — the version the local edits
+   *  started from. It's the common ancestor the sync merge needs to tell "I
+   *  changed this" from "the other instance changed this" (see data/merge). Set
+   *  on load and updated on every successful push. */
+  baseText = /* @__PURE__ */ new Map();
+  markDirty(path) {
+    this.dirty.add(path);
+  }
+  clearDirty() {
+    this.dirty.clear();
+  }
+};
+var mounted;
+function mountFileMap(map) {
+  mounted = map;
+}
+function fileMap() {
+  if (!mounted) {
+    throw new Error("No repository is mounted.");
+  }
+  return mounted;
+}
+async function readText(path) {
+  return fileMap().text.get(path);
+}
+async function writeText(path, text) {
+  const fm = fileMap();
+  fm.deleted.delete(path);
+  fm.text.set(path, text);
+  fm.markDirty(path);
+}
+async function ensureDir(_path) {
+}
+function defaultConfig() {
+  return {
+    hoursPerDay: DEFAULT_HOURS_PER_DAY,
+    weekStart: DEFAULT_WEEK_START,
+    todosPerPage: DEFAULT_TODOS_PER_PAGE,
+    defaultTaskSort: { ...DEFAULT_TASK_SORT },
+    codeTheme: DEFAULT_CODE_THEME,
+    clients: [],
+    // Copied, not shared: the caller may edit the result, and the status editor
+    // splices this very array when config.json is missing.
+    statuses: DEFAULT_STATUSES.map((s) => ({ ...s })),
+    autoSync: parseAutoSync(void 0),
+    features: { ...DEFAULT_FEATURES },
+    aiAgents: []
+  };
+}
+var Workspace = class {
+  get configDir() {
+    return ".worklog";
+  }
+  get configFile() {
+    return ".worklog/config.json";
+  }
+  get clientsDir() {
+    return "clients";
+  }
+  get archiveDir() {
+    return "archive";
+  }
+  get worklogDir() {
+    return "worklog";
+  }
+  get notesDir() {
+    return "notes";
+  }
+  get listsDir() {
+    return "lists";
+  }
+  get meetingsDir() {
+    return "meetings";
+  }
+  get assetsDir() {
+    return "assets";
+  }
+  get appFile() {
+    return "worklog.worklog";
+  }
+  clientFile(clientId) {
+    return `clients/${clientId}.md`;
+  }
+  archiveFile(clientId, month) {
+    return `archive/${clientId}/${month}.md`;
+  }
+  worklogFile(month) {
+    return `worklog/${month}.md`;
+  }
+  notesFile(month) {
+    return `notes/${month}.md`;
+  }
+  listFile(listId) {
+    return `lists/${listId}.md`;
+  }
+  meetingsFile(month) {
+    return `meetings/${month}.md`;
+  }
+  async loadConfig() {
+    const raw = await readText(this.configFile);
+    if (raw === void 0) {
+      return defaultConfig();
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return {
+        hoursPerDay: parsed.hoursPerDay && parsed.hoursPerDay > 0 ? parsed.hoursPerDay : DEFAULT_HOURS_PER_DAY,
+        weekStart: parseWeekStart(parsed.weekStart),
+        todosPerPage: parseTodosPerPage(parsed.todosPerPage),
+        // Absent in every repo written before this setting existed, so the
+        // fallback is the order those repos have always been shown in.
+        defaultTaskSort: normalizeTaskSort(parsed.defaultTaskSort),
+        // Absent in every repo written before this setting existed, and absent
+        // reads as "follow the OS" — see normalizeCodeTheme.
+        codeTheme: normalizeCodeTheme(parsed.codeTheme),
+        // `archived`, `description` and `links` are normalized to value-or-absent
+        // so they never round-trip a stray value into config.json (JSON.stringify
+        // drops the undefined).
+        clients: Array.isArray(parsed.clients) ? parsed.clients.filter((c) => !!c && !!c.id).map((c) => ({
+          ...c,
+          description: typeof c.description === "string" && c.description.trim() ? c.description : void 0,
+          links: parseClientLinks(c.links),
+          archived: c.archived === true ? true : void 0
+        })) : [],
+        // Normalized rather than trusted: a hand-edited list with no closing
+        // status, two of them, or duplicate ids has to read as *something*, and
+        // every caller assumes exactly one terminal status sitting last.
+        statuses: normalizeStatuses(parsed.statuses),
+        autoSync: parseAutoSync(parsed.autoSync),
+        // Absent means both on, which is what every repo written before these
+        // switches existed expects.
+        features: parseFeatures(parsed.features),
+        // Absent in every repo written before this setting existed, and absent is
+        // the same answer as "none switched on" — no agent is offered by default.
+        aiAgents: parseAiAgents(parsed.aiAgents)
+      };
+    } catch {
+      return defaultConfig();
+    }
+  }
+  async saveConfig(config) {
+    await writeText(this.configFile, JSON.stringify(config, null, 2) + "\n");
+  }
+};
+function stem(path) {
+  const base = path.split("/").pop() ?? path;
+  return base.replace(/\.[^.]+$/, "");
+}
+function dirName(path) {
+  const parts = path.split("/");
+  parts.pop();
+  return parts.pop() ?? "";
+}
+
+// src/model/todos.ts
+var GENERAL_TODO_CLIENT_ID = "todos";
+var GENERAL_TODO_LABEL = "To-dos";
+var GENERAL_TODO_COLOR = "#64748b";
+function isGeneralTodoClientId(id) {
+  return id === GENERAL_TODO_CLIENT_ID;
+}
+function generalTodoClient() {
+  return { id: GENERAL_TODO_CLIENT_ID, name: GENERAL_TODO_LABEL, color: GENERAL_TODO_COLOR };
+}
+
+// src/model/worklog.ts
+var EVENT_WORKLOG_PREFIX = "event:";
+function eventWorklogClientId(eventType) {
+  const normalized = eventType.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!normalized) {
+    throw new Error("Event type is required.");
+  }
+  return `${EVENT_WORKLOG_PREFIX}${normalized}`;
+}
+function isEventWorklogClientId(clientId) {
+  return clientId.startsWith(EVENT_WORKLOG_PREFIX);
+}
+function eventTypeFromClientId(clientId) {
+  return isEventWorklogClientId(clientId) ? clientId.slice(EVENT_WORKLOG_PREFIX.length) : "";
+}
+function formatEventTypeLabel(eventType) {
+  return eventType.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+var EVENT_TYPES = [
+  { id: "vacation", label: "Vacation" },
+  { id: "public-holiday", label: "Public holiday" },
+  { id: "out-of-office", label: "Out of office" },
+  { id: "conference", label: "Conference" },
+  { id: "sick", label: "Sick day" },
+  { id: "other", label: "Other" }
+];
+function eventLabel(eventType) {
+  return EVENT_TYPES.find((e) => e.id === eventType)?.label ?? formatEventTypeLabel(eventType);
+}
+function roundHours(n) {
+  return Math.round(n * 100) / 100;
+}
+function resolveHours(amount, hoursPerDay) {
+  if (amount === "full") {
+    return hoursPerDay;
+  }
+  if (amount === "half") {
+    return hoursPerDay / 2;
+  }
+  const hours = typeof amount === "number" ? amount : Number(amount.trim().replace(/h$/i, ""));
+  return isFinite(hours) && hours >= 0 && String(amount).trim() !== "" ? roundHours(hours) : void 0;
+}
+function unloggableReason(clients, clientId) {
+  if (isGeneralTodoClientId(clientId)) {
+    return "The general to-do list belongs to no client, so it has no hours.";
+  }
+  const client = clients.find((c) => c.id === clientId);
+  if (!client) {
+    return `Unknown client "${clientId}".`;
+  }
+  if (client.archived) {
+    return `"${client.name}" is archived; restore it in Settings to log time on it.`;
+  }
+  return void 0;
+}
+
+// src/model/recurringTask.ts
+function withSeededDue(task, from = today()) {
+  if (!task.repeat || task.due || task.completed) {
+    return task;
+  }
+  const start = firstOccurrence(task.repeat, from);
+  return start ? { ...task, due: start } : task;
+}
+
+// src/workspace/indexer.ts
+async function rebuild(db, ws) {
+  const config = await ws.loadConfig();
+  const fm = fileMap();
+  const tasks = [];
+  const worklog = [];
+  const dayNotes = [];
+  const checklists = [];
+  const meetings = [];
+  for (const [path, text] of fm.text) {
+    if (/^clients\/[^/]+\.md$/.test(path)) {
+      tasks.push(...parseTaskFile(text, path, stem(path)).tasks);
+      continue;
+    }
+    if (/^archive\/[^/]+\/[^/]+\.md$/.test(path)) {
+      tasks.push(...parseTaskFile(text, path, dirName(path)).tasks);
+      continue;
+    }
+    if (/^worklog\/[^/]+\.md$/.test(path)) {
+      worklog.push(...parseWorklogFile(text, path));
+      continue;
+    }
+    if (/^notes\/[^/]+\.md$/.test(path)) {
+      dayNotes.push(...parseDayNotesFile(text, path));
+      continue;
+    }
+    if (/^lists\/[^/]+\.md$/.test(path)) {
+      checklists.push(parseChecklistFile(text, path, stem(path)));
+      continue;
+    }
+    if (/^meetings\/[^/]+\.md$/.test(path)) {
+      meetings.push(...parseMeetingFile(text, path));
+      continue;
+    }
+  }
+  const seeded = tasks.map((t) => withSeededDue(t));
+  const clients = mergeClients(config.clients, seeded, worklog);
+  db.reset();
+  db.load({ clients, tasks: seeded, worklog, dayNotes, checklists, meetings });
+  return {
+    clients: clients.length,
+    tasks: seeded.length,
+    worklog: worklog.length,
+    dayNotes: dayNotes.length,
+    checklists: checklists.length,
+    meetings: meetings.length
+  };
+}
+function mergeClients(configured, tasks, worklog) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const c of configured) {
+    byId.set(c.id, c);
+  }
+  const ensure = (id) => {
+    if (id && !byId.has(id)) {
+      byId.set(id, { id, name: id });
+    }
+  };
+  for (const t of tasks) {
+    t.clientIds.forEach(ensure);
+  }
+  for (const w of worklog) {
+    if (!isEventWorklogClientId(w.clientId)) {
+      ensure(w.clientId);
+    }
+  }
+  return [...byId.values()];
+}
+
+// src/store.ts
+var Store = class {
+  db = new MemoryDb();
+  ws = new Workspace();
+  config;
+  listeners = /* @__PURE__ */ new Set();
+  /** Rebuild from the mounted file map (called once after load, then after each edit). */
+  async rebuild(reason) {
+    this.config = await this.ws.loadConfig();
+    await rebuild(this.db, this.ws);
+    this.emitChange(reason);
+  }
+  getConfig() {
+    return this.config;
+  }
+  onDidChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emitChange(reason) {
+    for (const l of this.listeners) {
+      l(reason);
+    }
+  }
+};
+
+// src/server/github.ts
+function isWorklogPath(path) {
+  return path === ".worklog/config.json" || path === "worklog.worklog" || /^clients\/[^/]+\.md$/.test(path) || /^archive\/[^/]+\/[^/]+\.md$/.test(path) || /^worklog\/[^/]+\.md$/.test(path) || /^notes\/[^/]+\.md$/.test(path) || /^lists\/[^/]+\.md$/.test(path) || /^meetings\/[^/]+\.md$/.test(path) || /^assets\/[^/]+$/.test(path);
+}
+
+// src/model/priority.ts
+var NORMAL_PRIORITY_ID = "normal";
+var NORMAL = { id: NORMAL_PRIORITY_ID, label: "Normal", rank: 2 };
+var PRIORITIES = [
+  { id: "urgent", label: "Urgent", rank: 0 },
+  { id: "high", label: "High", rank: 1 },
+  NORMAL,
+  { id: "low", label: "Low", rank: 3 }
+];
+var BY_ID = new Map(PRIORITIES.map((p) => [p.id, p]));
+function priorityDef(raw) {
+  return raw ? BY_ID.get(raw.trim().toLowerCase()) : void 0;
+}
+function priorityRank(raw) {
+  return (priorityDef(raw) ?? NORMAL).rank;
+}
+function writablePriority(raw) {
+  const def = priorityDef(raw);
+  return def && def.id !== NORMAL_PRIORITY_ID ? def.id : void 0;
+}
+
+// src/parser/ids.ts
+var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+function newTaskId(size = 6) {
+  return "t_" + randomToken(size);
+}
+function randomToken(size) {
+  const bytes = new Uint8Array(size);
+  crypto.getRandomValues(bytes);
+  let out = "";
+  for (let i = 0; i < size; i++) {
+    out += ALPHABET[bytes[i] % ALPHABET.length];
+  }
+  return out;
+}
+
+// src/services/assets.ts
+var MAX_BYTES = 10 * 1024 * 1024;
+
+// src/commands/shared.ts
+async function appendTaskBlock(ws, client, block) {
+  await ensureDir(ws.clientsDir);
+  const path = ws.clientFile(client.id);
+  const existing = await readText(path);
+  let content;
+  if (existing === void 0 || existing.trim() === "") {
+    content = `# ${client.name}
+
+${block}
+`;
+  } else {
+    content = existing.replace(/\s+$/, "") + "\n\n" + block + "\n";
+  }
+  await writeText(path, content);
+}
+async function appendArchiveBlock(ws, clientId, clientName, month, block) {
+  await ensureDir(`${ws.archiveDir}/${clientId}`);
+  const path = ws.archiveFile(clientId, month);
+  const existing = await readText(path);
+  let content;
+  if (existing === void 0 || existing.trim() === "") {
+    content = `# ${clientName} \u2014 ${month}
+
+${block}
+`;
+  } else {
+    content = existing.replace(/\s+$/, "") + "\n\n" + block + "\n";
+  }
+  await writeText(path, content);
+}
+
+// src/services/taskOps.ts
+function collectDescendants(store, taskId) {
+  const out = [];
+  const visit = (id) => {
+    for (const child of store.db.getChildren(id)) {
+      out.push(child);
+      visit(child.id);
+    }
+  };
+  visit(taskId);
+  return out;
+}
+function isClosed(task) {
+  return !!task.completed;
+}
+async function setTaskStatus(store, taskId, statusId) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  const statuses = store.getConfig().statuses;
+  const goingTerminal = isTerminalStatus(statuses, statusId);
+  if (goingTerminal && !isClosed(task)) {
+    return closeCascade(store, taskId, statusId, today());
+  }
+  if (!goingTerminal && isClosed(task)) {
+    return reopenTask(store, taskId, statusId);
+  }
+  await updateInPlace(store, task, (t) => ({ ...t, status: statusId }));
+  await store.rebuild("setStatus");
+  return { ...task, status: statusId };
+}
+async function toggleTaskWorkedOn(store, taskId, date) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  if (isGeneralTodoClientId(task.clientIds[0])) {
+    throw new Error("To-dos don't track worked-on days \u2014 they're open or closed.");
+  }
+  const existing = new Set(task.workedOn ?? []);
+  const marking = !existing.has(date);
+  if (marking) {
+    existing.add(date);
+  } else {
+    existing.delete(date);
+  }
+  const workedOn = [...existing].sort();
+  const wip = marking && !isClosed(task) ? inProgressStatusId(store.getConfig().statuses) : void 0;
+  await updateInPlace(store, task, (t) => ({
+    ...t,
+    workedOn,
+    status: wip ?? t.status
+  }));
+  await store.rebuild("toggleWorked");
+  return { ...task, workedOn, status: wip ?? task.status };
+}
+async function addTaskNote(store, taskId, text) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  const trimmed = text.trim();
+  if (!trimmed) {
+    throw new Error("Cannot add an empty note.");
+  }
+  const note = { timestamp: nowStamp(), text: trimmed };
+  await updateInPlace(store, task, (t) => ({
+    ...t,
+    notes: [...t.notes ?? [], note]
+  }));
+  await store.rebuild("addNote");
+  return store.db.getTask(taskId) ?? task;
+}
+async function closeTaskById(store, taskId, completedDate = today()) {
+  const terminal = terminalStatusId(store.getConfig().statuses);
+  return closeCascade(store, taskId, terminal, completedDate);
+}
+async function closeCascade(store, taskId, statusId, completedDate, endSeries = false) {
+  const root = store.db.getTask(taskId);
+  if (!root) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  const openDescendants = collectDescendants(store, taskId).filter(
+    (t) => !isClosed(t)
+  );
+  for (const child of openDescendants) {
+    await closeOne(store, child, statusId, completedDate, endSeries);
+  }
+  const closed = await closeOne(store, root, statusId, completedDate, endSeries);
+  await store.rebuild("closeTask");
+  return closed;
+}
+async function closeOne(store, task, statusId, completedDate, endSeries = false) {
+  const clientId = task.clientIds[0];
+  const clientName = store.db.getClients().find((c) => c.id === clientId)?.name ?? clientId;
+  const clientUri = store.ws.clientFile(clientId);
+  const content = await readText(clientUri);
+  if (content === void 0) {
+    throw new Error(`Could not read ${clientId}.md to close "${task.title}".`);
+  }
+  const extracted = extractBlock(content, task.id);
+  if (!extracted) {
+    throw new Error(`Could not locate task ${task.id} in ${clientId}.md.`);
+  }
+  const source = withSeededDue(
+    parseTaskFile(extracted.block, clientUri, clientId).tasks[0] ?? task
+  );
+  if (source.repeat && !endSeries) {
+    const nextDue = nextDueAfterCompletion(
+      source.repeat,
+      source.due,
+      completedDate
+    );
+    if (nextDue) {
+      return rollOccurrence(store, {
+        source,
+        clientId,
+        clientName,
+        clientUri,
+        content,
+        statusId,
+        completedDate,
+        nextDue
+      });
+    }
+  }
+  const closed = {
+    ...source,
+    status: statusId,
+    completed: completedDate
+  };
+  await writeText(clientUri, extracted.remainder);
+  await appendArchiveBlock(
+    store.ws,
+    clientId,
+    clientName,
+    monthOf(closed.completed),
+    serializeTask(closed, clientId)
+  );
+  return closed;
+}
+async function rollOccurrence(store, args) {
+  const { source, clientId, clientName, clientUri, content } = args;
+  const snapshot = {
+    ...source,
+    id: newTaskId(),
+    status: args.statusId,
+    completed: args.completedDate,
+    repeat: void 0,
+    lastDone: void 0,
+    repeatOf: source.id
+  };
+  const live = {
+    ...source,
+    status: openStatusId(store.getConfig().statuses),
+    due: args.nextDue,
+    lastDone: args.completedDate,
+    completed: void 0,
+    notes: void 0,
+    // The queue is the plan and comes along; the prompts that ran belong to the
+    // occurrence that ran them and stay on its snapshot, or a weekly task would
+    // carry every prompt it ever ran into every future week.
+    prompts: queuedPrompts(source.prompts),
+    // Same reasoning one step further: the steps are the plan for the series and
+    // come along, but unticked — the ticks belong to the occurrence that earned
+    // them and stay on its snapshot.
+    checklist: untickedChecklist(source.checklist),
+    workedOn: void 0
+  };
+  const replaced = replaceBlock(
+    content,
+    source.id,
+    serializeTask(live, clientId)
+  );
+  if (replaced === void 0) {
+    throw new Error(`Could not locate task ${source.id} to roll forward.`);
+  }
+  await writeText(clientUri, replaced.replace(/\s*$/, "") + "\n");
+  await appendArchiveBlock(
+    store.ws,
+    clientId,
+    clientName,
+    monthOf(args.completedDate),
+    serializeTask(snapshot, clientId)
+  );
+  return live;
+}
+function queuedPrompts(prompts) {
+  const queued = (prompts ?? []).filter((p) => !p.ran);
+  return queued.length ? queued : void 0;
+}
+function untickedChecklist(checklist) {
+  return checklist?.length ? checklist.map((i) => ({ ...i, done: false })) : void 0;
+}
+async function reopenTask(store, taskId, statusId) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  if (task.repeatOf) {
+    const template = store.db.getTask(task.repeatOf);
+    if (template?.repeat) {
+      return undoOccurrence(store, task, template, statusId);
+    }
+  }
+  const clientId = task.clientIds[0];
+  const client = store.db.getClients().find((c) => c.id === clientId);
+  const archiveUri = task.sourceFile;
+  const content = await readText(archiveUri);
+  if (content === void 0) {
+    throw new Error(`Could not read the archive file for "${task.title}".`);
+  }
+  const extracted = extractBlock(content, task.id);
+  if (!extracted) {
+    throw new Error(`Could not locate task ${task.id} in the archive.`);
+  }
+  const parsed = parseTaskFile(extracted.block, archiveUri, clientId).tasks[0];
+  const reopened = {
+    ...parsed ?? task,
+    status: statusId,
+    completed: void 0
+  };
+  await writeText(archiveUri, extracted.remainder);
+  await appendTaskBlock(
+    store.ws,
+    client ?? { id: clientId, name: clientId },
+    serializeTask(reopened, clientId)
+  );
+  await store.rebuild("reopenTask");
+  return reopened;
+}
+async function undoOccurrence(store, snapshot, template, statusId) {
+  const archiveUri = snapshot.sourceFile;
+  const archiveContent = await readText(archiveUri);
+  if (archiveContent === void 0) {
+    throw new Error(`Could not read the archive file for "${snapshot.title}".`);
+  }
+  const extracted = extractBlock(archiveContent, snapshot.id);
+  if (!extracted) {
+    throw new Error(`Could not locate occurrence ${snapshot.id} in the archive.`);
+  }
+  const previous = store.db.occurrencesOf(template.id).find((o) => o.id !== snapshot.id && o.completed);
+  await writeText(archiveUri, extracted.remainder);
+  await updateInPlace(store, template, (t) => ({
+    ...t,
+    status: statusId,
+    due: snapshot.due,
+    lastDone: previous?.completed,
+    notes: snapshot.notes,
+    prompts: snapshot.prompts,
+    checklist: snapshot.checklist,
+    workedOn: snapshot.workedOn
+  }));
+  await store.rebuild("undoOccurrence");
+  return store.db.getTask(template.id) ?? template;
+}
+async function updateTask(store, taskId, fields) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  const current = task.clientIds[0];
+  const target = fields.clientId && fields.clientId.trim() ? fields.clientId : current;
+  const apply = (t) => withSeededDue({
+    ...t,
+    title: fields.title !== void 0 ? fields.title.trim() || t.title : t.title,
+    // Passing the field at all is a decision about priority, so an unrecognised
+    // value clears it rather than leaving the old one standing.
+    priority: fields.priority !== void 0 ? writablePriority(fields.priority) : t.priority,
+    parentId: fields.parentId !== void 0 ? fields.parentId || void 0 : t.parentId,
+    links: fields.links !== void 0 ? parseLinks(fields.links) : t.links,
+    description: fields.description !== void 0 ? fields.description.trim() || void 0 : t.description,
+    due: fields.due !== void 0 ? fields.due.trim() || void 0 : t.due,
+    tags: fields.tags !== void 0 ? fields.tags.map((tag) => tag.trim()).filter(Boolean) : t.tags,
+    repeat: fields.repeat !== void 0 ? fields.repeat ?? void 0 : t.repeat,
+    // Dropping the rule drops the series' bookkeeping with it.
+    lastDone: fields.repeat === null ? void 0 : t.lastDone
+  });
+  if (target === current) {
+    await updateInPlace(store, task, apply);
+  } else {
+    const uri = task.sourceFile;
+    const content = await readText(uri);
+    if (content === void 0) {
+      throw new Error(`Could not read ${task.sourceFile}.`);
+    }
+    const extracted = extractBlock(content, task.id);
+    if (!extracted) {
+      throw new Error(`Could not locate task ${task.id}.`);
+    }
+    const parsed = parseTaskFile(extracted.block, uri, current).tasks[0] ?? task;
+    const moved = apply({ ...parsed, clientIds: [target] });
+    await writeText(uri, extracted.remainder);
+    if (moved.completed) {
+      const name = store.db.getClients().find((c) => c.id === target)?.name ?? target;
+      await appendArchiveBlock(
+        store.ws,
+        target,
+        name,
+        monthOf(moved.completed),
+        serializeTask(moved, target)
+      );
+    } else {
+      const client = store.db.getClients().find((c) => c.id === target) ?? {
+        id: target,
+        name: target
+      };
+      await appendTaskBlock(store.ws, client, serializeTask(moved, target));
+    }
+  }
+  await store.rebuild("updateTask");
+  return store.db.getTask(taskId) ?? task;
+}
+async function updateInPlace(store, task, mutate) {
+  const uri = task.sourceFile;
+  const content = await readText(uri);
+  if (content === void 0) {
+    throw new Error(`Could not read ${task.sourceFile}.`);
+  }
+  const parsed = parseTaskFile(
+    extractBlockText(content, task.id),
+    uri,
+    task.clientIds[0]
+  ).tasks[0] ?? task;
+  const next = mutate({ ...parsed, clientIds: task.clientIds });
+  const replaced = replaceBlock(
+    content,
+    task.id,
+    serializeTask(next, task.clientIds[0])
+  );
+  if (replaced === void 0) {
+    throw new Error(`Could not locate task ${task.id} to update.`);
+  }
+  await writeText(uri, replaced.replace(/\s*$/, "") + "\n");
+}
+function extractBlockText(content, taskId) {
+  return extractBlock(content, taskId)?.block ?? "";
+}
+
+// src/services/tasks.ts
+async function createTask(store, input) {
+  const title = input.title.trim();
+  if (!title) {
+    throw new Error("A task title is required.");
+  }
+  const client = store.db.getClients().find((c) => c.id === input.clientId) ?? (isGeneralTodoClientId(input.clientId) ? generalTodoClient() : void 0);
+  if (!client) {
+    throw new Error(`Unknown client "${input.clientId}".`);
+  }
+  const task = {
+    id: newTaskId(),
+    title,
+    description: input.description?.trim() || void 0,
+    // The configured first working status, not the literal 'open': the list is
+    // the user's, and a renamed or removed first status would otherwise mint
+    // tasks in a status nothing knows about.
+    status: openStatusId(store.getConfig().statuses),
+    priority: writablePriority(input.priority),
+    parentId: input.parentId || void 0,
+    clientIds: [client.id],
+    links: parseLinks(input.links),
+    created: today(),
+    due: input.due?.trim() || void 0,
+    repeat: input.repeat,
+    tags: (input.tags ?? []).map((t) => t.trim()).filter(Boolean),
+    sourceFile: "",
+    sourceLine: 0
+  };
+  const seeded = withSeededDue(task);
+  await appendTaskBlock(store.ws, client, serializeTask(seeded, client.id));
+  await store.rebuild("addTask");
+  return seeded;
+}
+
+// src/services/logWork.ts
+async function logWork(store, input) {
+  const date = input.date ?? today();
+  let task = findTask(store, input);
+  const created = !task;
+  if (!task) {
+    task = await createTask(store, {
+      clientId: input.clientId,
+      title: input.title,
+      links: input.link ? [input.link] : void 0
+    });
+  }
+  const markedWorked = !(task.workedOn ?? []).includes(date);
+  if (markedWorked) {
+    task = await toggleTaskWorkedOn(store, task.id, date);
+  }
+  const note = input.note?.trim();
+  const noteAdded = !!note && !(task.notes ?? []).some((n) => n.timestamp.startsWith(today()) && n.text === note);
+  if (noteAdded) {
+    task = await addTaskNote(store, task.id, note);
+  }
+  return { task: store.db.getTask(task.id) ?? task, created, markedWorked, noteAdded };
+}
+function findTask(store, input) {
+  if (input.taskId) {
+    const byId = store.db.getTask(input.taskId);
+    if (!byId) {
+      throw new Error(`Task ${input.taskId} not found.`);
+    }
+    return byId;
+  }
+  const all = store.db.getAllTasks().filter((t) => t.clientIds.includes(input.clientId));
+  const link = input.link ? normalizeUrl(input.link) : void 0;
+  const byLink = link ? all.find((t) => t.links.some((l) => normalizeUrl(l.url) === link)) : void 0;
+  const title = input.title.trim().toLowerCase();
+  return byLink ?? all.find((t) => !t.completed && t.title.trim().toLowerCase() === title);
+}
+function normalizeUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+
+// src/services/editTask.ts
+function requireTask(store, ref, { includeClosed = false } = {}) {
+  if (ref.taskId) {
+    const byId = store.db.getTask(ref.taskId);
+    if (!byId) {
+      throw new Error(`Task ${ref.taskId} not found.`);
+    }
+    return byId;
+  }
+  if (!ref.link && !ref.title) {
+    throw new Error("Name the task with an id, a link or a title.");
+  }
+  const scoped = store.db.getAllTasks().filter((t) => !ref.clientId || t.clientIds.includes(ref.clientId));
+  const link = ref.link ? normalizeUrl(ref.link) : void 0;
+  const title = ref.title?.trim().toLowerCase();
+  const matches = scoped.filter(
+    (t) => link ? t.links.some((l) => normalizeUrl(l.url) === link) : t.title.trim().toLowerCase() === title
+  );
+  const named = link ? `linked to ${ref.link}` : `called "${ref.title}"`;
+  const open = matches.filter((t) => !t.completed);
+  if (open.length > 1) {
+    const list2 = open.map((t) => `${t.id} (${t.sourceFile})`).join(", ");
+    throw new Error(`Several open tasks are ${named}: ${list2}. Pass --id, or --client to narrow it down.`);
+  }
+  if (open.length === 1) {
+    return open[0];
+  }
+  const closed = matches.filter((t) => t.completed).sort((a, b) => (b.completed ?? "").localeCompare(a.completed ?? ""))[0];
+  if (includeClosed && closed) {
+    return closed;
+  }
+  throw new Error(`No open task is ${named}${ref.clientId ? ` for client "${ref.clientId}"` : ""}.`);
+}
+async function editTask(store, ref, edit) {
+  let task = requireTask(store, ref);
+  const fields = {};
+  const changed = [];
+  const title = edit.title?.trim();
+  if (title && title !== task.title) {
+    fields.title = title;
+    changed.push("title");
+  }
+  if (edit.due !== void 0 && (edit.due ?? void 0) !== task.due) {
+    fields.due = edit.due ?? "";
+    changed.push("due");
+  }
+  if (edit.priority !== void 0 && writablePriority(edit.priority) !== writablePriority(task.priority)) {
+    fields.priority = edit.priority;
+    changed.push("priority");
+  }
+  if (edit.description !== void 0 && (edit.description.trim() || void 0) !== task.description) {
+    fields.description = edit.description;
+    changed.push("description");
+  }
+  if (edit.addTags?.length || edit.removeTags?.length) {
+    const current = task.tags ?? [];
+    const remove = new Set((edit.removeTags ?? []).map((t) => t.trim().toLowerCase()));
+    const kept = current.filter((t) => !remove.has(t.toLowerCase()));
+    const added = (edit.addTags ?? []).map((t) => t.trim()).filter((t) => t && !kept.some((k) => k.toLowerCase() === t.toLowerCase()));
+    const tags = [...kept, ...added];
+    if (tags.join("\n") !== current.join("\n")) {
+      fields.tags = tags;
+      changed.push("tags");
+    }
+  }
+  if (edit.parentId !== void 0 && (edit.parentId ?? void 0) !== task.parentId) {
+    if (edit.parentId) {
+      requireParent(store, edit.parentId, task.id);
+    }
+    fields.parentId = edit.parentId ?? "";
+    changed.push("parent");
+  }
+  if (Object.keys(fields).length > 0) {
+    task = await updateTask(store, task.id, fields);
+  }
+  if (edit.status !== void 0 && edit.status !== task.status) {
+    const statuses = store.getConfig().statuses;
+    if (!statuses.some((s) => s.id === edit.status)) {
+      throw new Error(`Unknown status "${edit.status}". Known: ${statuses.map((s) => s.id).join(", ")}.`);
+    }
+    task = await setTaskStatus(store, task.id, edit.status);
+    changed.push("status");
+  }
+  return { task: store.db.getTask(task.id) ?? task, changed };
+}
+async function closeTask(store, ref) {
+  const task = requireTask(store, ref, { includeClosed: true });
+  if (task.completed || task.repeat && task.lastDone === today()) {
+    return { task, closed: false };
+  }
+  const closed = await closeTaskById(store, task.id);
+  return { task: store.db.getTask(task.id) ?? closed, closed: true };
+}
+function requireParent(store, parentId, childId) {
+  const parent = store.db.getTask(parentId);
+  if (!parent) {
+    throw new Error(`Parent task ${parentId} not found.`);
+  }
+  for (let p = parent; p; p = p.parentId ? store.db.getTask(p.parentId) : void 0) {
+    if (p.id === childId) {
+      throw new Error(`Task ${childId} can't go under ${parentId}: that is the task itself or one of its subtasks.`);
+    }
+  }
+  return parent;
+}
+
+// src/services/addTask.ts
+async function addTask(store, input) {
+  const existing = findTask(store, input);
+  if (existing) {
+    return { task: existing, created: false };
+  }
+  if (input.parentId) {
+    requireParent(store, input.parentId);
+  }
+  const task = await createTask(store, {
+    clientId: input.clientId,
+    title: input.title,
+    links: input.link ? [input.link] : void 0,
+    due: input.due,
+    priority: input.priority,
+    description: input.description,
+    tags: input.tags,
+    parentId: input.parentId
+  });
+  return { task: store.db.getTask(task.id) ?? task, created: true };
+}
+
+// src/services/listTasks.ts
+function listTasks(store, filter = {}) {
+  const tag = filter.tag?.trim().toLowerCase();
+  return store.db.getAllTasks().filter((t) => !t.completed).filter((t) => !filter.clientId || t.clientIds.includes(filter.clientId)).filter((t) => !filter.dueBy || !!t.due && t.due <= filter.dueBy).filter((t) => !tag || (t.tags ?? []).some((x) => x.toLowerCase() === tag)).sort(
+    (a, b) => (a.due ?? "\uFFFF").localeCompare(b.due ?? "\uFFFF") || priorityRank(a.priority) - priorityRank(b.priority) || (a.created ?? "").localeCompare(b.created ?? "")
+  );
+}
+
+// src/services/worklog.ts
+function withEntry(existing, month, date, clientId, hours, note) {
+  const line = serializeWorklogEntry({ date, clientId, hours, note });
+  if (existing === void 0 || existing.trim() === "") {
+    return `# Worklog ${month}
+
+${line}
+`;
+  }
+  const lines = existing.split(/\r?\n/);
+  const prefix = `- ${date} ${clientId} `;
+  const idx = lines.findIndex((l) => l.startsWith(prefix));
+  if (idx >= 0) {
+    lines[idx] = line;
+  } else {
+    let insertAt = lines.length;
+    while (insertAt > 0 && lines[insertAt - 1].trim() === "") {
+      insertAt--;
+    }
+    lines.splice(insertAt, 0, line);
+  }
+  return lines.join("\n").replace(/\s+$/, "") + "\n";
+}
+async function setWorklog(store, date, clientId, hours, note) {
+  if (!(hours > 0)) {
+    return removeWorklog(store, date, clientId);
+  }
+  const month = monthOf(date);
+  const uri = store.ws.worklogFile(month);
+  await ensureDir(store.ws.worklogDir);
+  const existing = await readText(uri);
+  await writeText(uri, withEntry(existing, month, date, clientId, hours, note));
+  await store.rebuild("setWorklog");
+}
+async function removeWorklog(store, date, clientId) {
+  const uri = store.ws.worklogFile(monthOf(date));
+  const existing = await readText(uri);
+  if (existing === void 0) {
+    return;
+  }
+  const prefix = `- ${date} ${clientId} `;
+  const lines = existing.split(/\r?\n/).filter((l) => !l.startsWith(prefix));
+  await writeText(uri, lines.join("\n").replace(/\s+$/, "") + "\n");
+  await store.rebuild("removeWorklog");
+}
+
+// src/services/logHours.ts
+async function logHours(store, input) {
+  const config = store.getConfig();
+  const date = input.date ?? today();
+  if (!!input.clientId === !!input.event) {
+    throw new Error("Name either a client or a day event.");
+  }
+  let target;
+  if (input.event) {
+    target = eventWorklogClientId(input.event);
+    if (!EVENT_TYPES.some((e) => e.id === eventTypeFromClientId(target))) {
+      throw new Error(`Unknown day event "${input.event}". Known: ${EVENT_TYPES.map((e) => e.id).join(", ")}.`);
+    }
+  } else {
+    target = input.clientId;
+    const reason = unloggableReason(store.db.getClients(), target);
+    if (reason) {
+      throw new Error(reason);
+    }
+  }
+  const hours = resolveHours(input.hours, config.hoursPerDay);
+  if (hours === void 0) {
+    throw new Error(`Hours must be full, half or a number, got "${input.hours}".`);
+  }
+  const previous = dayEntries(store, date).find((e) => e.clientId === target);
+  const note = input.note !== void 0 ? input.note.trim() || void 0 : previous?.note;
+  const changed = hours > 0 ? previous?.hours !== hours || previous?.note !== note : !!previous;
+  if (changed) {
+    await setWorklog(store, date, target, hours, note);
+  }
+  return {
+    target,
+    date,
+    hours,
+    previous,
+    changed,
+    dayTotal: roundHours(dayEntries(store, date).reduce((sum, e) => sum + e.hours, 0)),
+    hoursPerDay: config.hoursPerDay
+  };
+}
+function dayEntries(store, date) {
+  return store.db.getAllWorklog().filter((e) => e.date === date);
+}
+function targetLabel(store, target) {
+  if (isEventWorklogClientId(target)) {
+    return eventLabel(eventTypeFromClientId(target));
+  }
+  return store.db.getClients().find((c) => c.id === target)?.name ?? target;
+}
+
+// cli/worklog.ts
+var TEXT_PATH = /\.(md|json)$|\.worklog$/;
+var PUSH_ATTEMPTS = 3;
+var NONE = "none";
+var USAGE = `Usage: worklog <command> [options]
+
+  log     Work that was done: marks the day worked on a task (creating the task
+          when it's new) and adds the note.
+  add     Something still to do: creates an open task. No day is marked worked.
+          Without --client it goes on the general to-do list.
+  update  Changes an existing task: due date, priority, description, ...
+  done    Closes a task. A recurring one rolls on to its next occurrence.
+  list    Prints the open tasks. Read-only.
+  hours   Sets the hours worked for a client (or a day event) on a day. Without
+          --hours it prints what's logged that day.
+
+All but list, and hours without --hours, commit and push to your timesheet repo.
+
+Every command:
+  --repo <path>         timesheet clone (default: $WORKLOG_REPO)
+  --client <id>         client id from .worklog/config.json; "todos" is the
+                        general to-do list
+
+Naming a task (log, update, done):
+  --id <t_xxxxxx>       this exact task
+  --link <url>          the task linked to this issue/ticket url
+  --title <title>       the open task with this title
+
+log --client <id> --title <title>:
+  --note <text>         progress note added to the task
+  --date <date>         day worked, YYYY-MM-DD (default: today)
+
+add --title <title>:
+  --link <url>          issue/ticket url
+  --due <date>          day the task is due, YYYY-MM-DD
+  --priority <level>    ${PRIORITIES.map((p) => p.id).join(", ")}
+  --description <text>  what the task is about
+  --tag <tag>           repeat for several tags
+  --parent <t_xxxxxx>   make it a subtask of this task
+
+update:
+  --rename <title>      new title
+  --due <date|none>     new due date, or none to clear it
+  --priority <level>    new priority; normal clears it
+  --description <text>  new description; "" clears it
+  --status <id>         a status from .worklog/config.json
+  --tag <tag>           add a tag (repeatable)
+  --untag <tag>         remove a tag (repeatable)
+  --parent <id|none>    move it under this task, or none to make it top-level
+
+hours --client <id> | --event <type>:
+  --hours <amount>      full, half, or a number of hours; 0 removes the entry.
+                        Sets the day's total for that client, it doesn't add
+  --date <date>         the day, YYYY-MM-DD (default: today)
+  --note <text>         what the time went to (default: keep the note there)
+  --event <type>        ${EVENT_TYPES.map((e) => e.id).join(", ")}
+
+list:
+  --due-by <date>       only tasks due on or before this day
+  --tag <tag>           only tasks with this tag
+  --json                print JSON instead of one line per task
+
+log, add, update, done, hours:
+  --dry-run             show the change, commit nothing`;
+var OPTIONS = {
+  log: ["client", "id", "link", "title", "note", "date", "dry-run"],
+  add: ["client", "link", "title", "due", "priority", "description", "tag", "parent", "dry-run"],
+  update: [
+    "client",
+    "id",
+    "link",
+    "title",
+    "rename",
+    "due",
+    "priority",
+    "description",
+    "status",
+    "tag",
+    "untag",
+    "parent",
+    "dry-run"
+  ],
+  done: ["client", "id", "link", "title", "dry-run"],
+  list: ["client", "due-by", "tag", "json"],
+  hours: ["client", "event", "hours", "date", "note", "dry-run"]
+};
+var HINTS = {
+  date: `A to-do's date is --due; --date is the day worked, for "worklog log" and "worklog hours".`,
+  due: "The day worked is --date; --due is when a to-do is due."
+};
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      client: { type: "string" },
+      title: { type: "string" },
+      link: { type: "string" },
+      id: { type: "string" },
+      note: { type: "string" },
+      date: { type: "string" },
+      due: { type: "string" },
+      "due-by": { type: "string" },
+      priority: { type: "string" },
+      description: { type: "string" },
+      rename: { type: "string" },
+      status: { type: "string" },
+      tag: { type: "string", multiple: true },
+      untag: { type: "string", multiple: true },
+      parent: { type: "string" },
+      event: { type: "string" },
+      hours: { type: "string" },
+      json: { type: "boolean" },
+      repo: { type: "string" },
+      "dry-run": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help || positionals.length === 0) {
+    console.log(USAGE);
+    return;
+  }
+  const command = positionals[0];
+  if (!(command in OPTIONS) || positionals.length > 1) {
+    throw new Error(`Unknown command "${positionals.join(" ")}".
+
+${USAGE}`);
+  }
+  const allowed = /* @__PURE__ */ new Set([...OPTIONS[command], "repo", "help"]);
+  const misplaced = Object.keys(values).find((o) => !allowed.has(o));
+  if (misplaced) {
+    const hint = HINTS[misplaced] ? ` ${HINTS[misplaced]}` : "";
+    throw new Error(`"worklog ${command}" has no --${misplaced} option.${hint}
+
+${USAGE}`);
+  }
+  validate(values);
+  const repo = values.repo ?? process.env.WORKLOG_REPO;
+  if (!repo) {
+    throw new Error("Point --repo or $WORKLOG_REPO at a clone of your timesheet repo.");
+  }
+  if (command === "list") {
+    return list(repo, values);
+  }
+  if (command === "hours" && values.hours === void 0) {
+    return showDay(repo, values.date ?? today());
+  }
+  return run(repo, toEdit(command, values), !!values["dry-run"]);
+}
+function validate(values) {
+  for (const option of ["date", "due", "due-by"]) {
+    const value = values[option];
+    if (typeof value === "string" && !(option === "due" && value === NONE) && !isValidISODate(value)) {
+      throw new Error(`--${option} must be YYYY-MM-DD, got "${value}".`);
+    }
+  }
+  const priority = values.priority;
+  if (typeof priority === "string" && !PRIORITIES.some((p) => p.id === priority.trim().toLowerCase())) {
+    throw new Error(`--priority must be one of ${PRIORITIES.map((p) => p.id).join(", ")}, got "${priority}".`);
+  }
+}
+function toEdit(command, values) {
+  const str = (key) => values[key];
+  const list2 = (key) => values[key];
+  const ref = { taskId: str("id"), link: str("link"), title: str("title"), clientId: str("client") };
+  const orNull = (value) => value === NONE ? null : value;
+  switch (command) {
+    case "log": {
+      const clientId = str("client");
+      const title = str("title");
+      if (!clientId || !title) {
+        throw new Error(`--client and --title are required.
+
+${USAGE}`);
+      }
+      const input = { clientId, title, taskId: ref.taskId, link: ref.link, note: str("note"), date: str("date") };
+      return async (store) => describeLog(await logWork(store, input), input);
+    }
+    case "add": {
+      const title = str("title");
+      if (!title) {
+        throw new Error(`--title is required.
+
+${USAGE}`);
+      }
+      const input = {
+        clientId: str("client") ?? GENERAL_TODO_CLIENT_ID,
+        title,
+        link: ref.link,
+        due: str("due"),
+        priority: str("priority"),
+        description: str("description"),
+        tags: list2("tag"),
+        parentId: str("parent")
+      };
+      return async (store) => describeAdd(await addTask(store, input));
+    }
+    case "update": {
+      requireRef(ref);
+      const edit = {
+        title: str("rename"),
+        due: orNull(str("due")),
+        priority: str("priority"),
+        description: str("description"),
+        status: str("status"),
+        addTags: list2("tag"),
+        removeTags: list2("untag"),
+        parentId: orNull(str("parent"))
+      };
+      if (Object.values(edit).every((v) => v === void 0)) {
+        throw new Error(`Nothing to change: pass at least one of --rename, --due, --priority, --description, --status, --tag, --untag, --parent.`);
+      }
+      return async (store) => describeUpdate(await editTask(store, ref, edit));
+    }
+    case "hours": {
+      const input = { clientId: str("client"), event: str("event"), hours: str("hours") ?? "", note: str("note"), date: str("date") };
+      return async (store) => describeHours(store, await logHours(store, input));
+    }
+    default: {
+      requireRef(ref);
+      return async (store) => describeDone(await closeTask(store, ref));
+    }
+  }
+}
+function requireRef(ref) {
+  if (!ref.taskId && !ref.link && !ref.title) {
+    throw new Error(`Name the task with --id, --link or --title.
+
+${USAGE}`);
+  }
+}
+async function run(repo, edit, dryRun) {
+  const git = gitIn(repo);
+  if (git("status", "--porcelain", "--untracked-files=no")) {
+    throw new Error(`${repo} has uncommitted changes; commit or discard them first.`);
+  }
+  git("fetch", "--quiet");
+  if (git("rev-list", "--count", "@{u}..HEAD") !== "0") {
+    throw new Error(`${repo} has unpushed commits; push them first.`);
+  }
+  git("merge", "--ff-only", "--quiet", "@{u}");
+  for (let attempt = 1; ; attempt++) {
+    const { line, changed } = await applyToClone(repo, edit);
+    if (changed.length === 0) {
+      console.log(`${line} \u2014 nothing new to write`);
+      return;
+    }
+    if (dryRun) {
+      git("add", "--intent-to-add", "--", ...changed);
+      console.log(git("--no-pager", "diff", "--", ...changed));
+      git("reset", "--quiet", "--hard", "HEAD");
+      console.log(`${line} \u2014 dry run, nothing committed`);
+      return;
+    }
+    git("add", "--", ...changed);
+    git("commit", "--quiet", "-m", `chore: worklog sync ${today()}`);
+    try {
+      git("push", "--quiet");
+      console.log(`${line} \u2014 pushed ${git("rev-parse", "--short", "HEAD")}`);
+      return;
+    } catch (err) {
+      git("reset", "--quiet", "--hard", "@{u}");
+      const raced = /rejected|fetch first|non-fast-forward/.test(String(err.stderr));
+      if (!raced) {
+        throw new Error("Push failed; nothing was written.", { cause: err });
+      }
+      if (attempt >= PUSH_ATTEMPTS) {
+        throw new Error(`Push rejected ${PUSH_ATTEMPTS} times; nothing was written.`, { cause: err });
+      }
+      git("fetch", "--quiet");
+      git("reset", "--quiet", "--hard", "@{u}");
+    }
+  }
+}
+function catchUp(repo) {
+  const git = gitIn(repo);
+  try {
+    git("fetch", "--quiet");
+    if (git("status", "--porcelain", "--untracked-files=no") || git("rev-list", "--count", "@{u}..HEAD") !== "0") {
+      console.error(`${repo} has local changes; reading it as it is, without the latest from the remote.`);
+    } else {
+      git("merge", "--ff-only", "--quiet", "@{u}");
+    }
+  } catch {
+    console.error("Could not fetch the remote; reading the clone as it is.");
+  }
+}
+async function list(repo, values) {
+  catchUp(repo);
+  const { store } = await loadClone(repo);
+  const tasks = listTasks(store, {
+    clientId: values.client,
+    dueBy: values["due-by"],
+    tag: values.tag?.[0]
+  });
+  if (values.json) {
+    console.log(JSON.stringify(tasks.map(toJson), null, 2));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("No open tasks match.");
+    return;
+  }
+  for (const t of tasks) {
+    console.log(
+      [t.id, t.due ?? "-", t.priority ?? "-", t.clientIds[0], t.status, t.title].join("	")
+    );
+  }
+}
+async function showDay(repo, date) {
+  catchUp(repo);
+  const { store } = await loadClone(repo);
+  const entries = dayEntries(store, date);
+  const total = entries.reduce((sum, e) => sum + e.hours, 0);
+  console.log(`${date}: ${total}h logged of ${store.getConfig().hoursPerDay}h`);
+  for (const e of entries) {
+    console.log(["", e.clientId, `${e.hours}h`, targetLabel(store, e.clientId), e.note ?? ""].join("	").trimEnd());
+  }
+}
+function toJson(t) {
+  return {
+    id: t.id,
+    title: t.title,
+    client: t.clientIds[0],
+    status: t.status,
+    priority: t.priority ?? "normal",
+    due: t.due ?? null,
+    tags: t.tags ?? [],
+    links: t.links.map((l) => l.url),
+    parent: t.parentId ?? null,
+    repeats: !!t.repeat,
+    created: t.created ?? null,
+    description: t.description ?? null,
+    file: t.sourceFile
+  };
+}
+function gitIn(repo) {
+  return (...args) => execFileSync("git", ["-C", repo, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+async function loadClone(repo) {
+  const fm = new FileMap();
+  for (const path of listFiles(repo)) {
+    if (isWorklogPath(path) && TEXT_PATH.test(path)) {
+      fm.text.set(path, readFileSync(join(repo, path), "utf8"));
+      fm.remote.add(path);
+    }
+  }
+  mountFileMap(fm);
+  const store = new Store();
+  await store.rebuild("load");
+  return { store, fm };
+}
+async function applyToClone(repo, edit) {
+  const { store, fm } = await loadClone(repo);
+  const before = new Map(fm.text);
+  const line = await edit(store);
+  const changed = [...fm.dirty].filter((path) => fm.text.has(path) && fm.text.get(path) !== before.get(path));
+  for (const path of changed) {
+    mkdirSync(dirname(join(repo, path)), { recursive: true });
+    writeFileSync(join(repo, path), fm.text.get(path) ?? "");
+  }
+  return { line, changed };
+}
+function listFiles(repo) {
+  return readdirSync(repo, { recursive: true, withFileTypes: true }).filter((e) => e.isFile()).map((e) => relative(repo, join(e.parentPath, e.name)).split(sep).join("/")).filter((path) => !path.startsWith(".git/"));
+}
+function label(task) {
+  return `${task.id} "${task.title}" (${task.sourceFile})`;
+}
+function describeLog({ task, created, markedWorked, noteAdded }, input) {
+  const what = [
+    created ? "created" : "found",
+    markedWorked ? `marked worked ${input.date ?? today()}` : void 0,
+    noteAdded ? "note added" : void 0
+  ].filter(Boolean);
+  return `${label(task)}: ${what.join(", ")}`;
+}
+function describeAdd({ task, created }) {
+  const what = [
+    created ? "created" : "already exists, left as is",
+    task.due ? `due ${task.due}` : void 0,
+    task.priority ? `priority ${task.priority}` : void 0
+  ].filter(Boolean);
+  return `${label(task)}: ${what.join(", ")}`;
+}
+function describeUpdate({ task, changed }) {
+  return `${label(task)}: ${changed.length ? `changed ${changed.join(", ")}` : "already up to date"}`;
+}
+function describeHours(store, r) {
+  const was = !r.previous ? "new" : r.previous.hours === r.hours && r.changed ? "note updated" : `was ${r.previous.hours}h`;
+  const what = r.hours > 0 ? `${r.hours}h (${was})` : r.previous ? `removed (was ${r.previous.hours}h)` : "nothing logged";
+  return `${targetLabel(store, r.target)} on ${r.date}: ${what}; day total ${r.dayTotal}h of ${r.hoursPerDay}h`;
+}
+function describeDone({ task, closed }) {
+  if (!closed) {
+    return `${label(task)}: ${task.completed ? `already closed on ${task.completed}` : `already done today, next due ${task.due}`}`;
+  }
+  return `${label(task)}: ${task.completed ? "closed" : `done, next due ${task.due}`}`;
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});