@estruyf/worklog-cli 0.0.0-stage → 0.1.0

package/dist/worklog.js

@@ -0,0 +1,2058 @@
+#!/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 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 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;
+}
+
+// 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 label = typeof candidate.label === "string" ? candidate.label.trim() : "";
+    if (!id || !label || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    defs.push({
+      id,
+      label: label.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 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 label = typeof l.label === "string" ? l.label.trim() : "";
+    return { url: l.url.trim(), ...label ? { label } : {} };
+  });
+}
+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/worklog.ts
+var EVENT_WORKLOG_PREFIX = "event:";
+function isEventWorklogClientId(clientId) {
+  return clientId.startsWith(EVENT_WORKLOG_PREFIX);
+}
+
+// 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 writablePriority(raw) {
+  const def = priorityDef(raw);
+  return def && def.id !== NORMAL_PRIORITY_ID ? def.id : void 0;
+}
+
+// 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/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);
+}
+
+// src/services/taskOps.ts
+function isClosed(task) {
+  return !!task.completed;
+}
+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 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(/\/+$/, "");
+}
+
+// cli/worklog.ts
+var TEXT_PATH = /\.(md|json)$|\.worklog$/;
+var PUSH_ATTEMPTS = 3;
+var USAGE = `Usage: worklog log --client <id> --title <title> [options]
+
+Marks the day worked on a task in your timesheet repo (creating the task when
+it's new), adds the note, then commits and pushes.
+
+  --client <id>     client id from .worklog/config.json (required)
+  --title <title>   task title; used to create the task, or to find an open one (required)
+  --link <url>      issue/ticket url \u2014 finds the task again on later runs
+  --id <t_xxxxxx>   log on this exact task
+  --note <text>     progress note added to the task
+  --date <date>     day worked, YYYY-MM-DD (default: today)
+  --repo <path>     timesheet clone (default: $WORKLOG_REPO)
+  --dry-run         show the change, commit nothing`;
+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" },
+      repo: { type: "string" },
+      "dry-run": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help || positionals.length === 0) {
+    console.log(USAGE);
+    return;
+  }
+  if (positionals[0] !== "log" || positionals.length > 1) {
+    throw new Error(`Unknown command "${positionals.join(" ")}".
+
+${USAGE}`);
+  }
+  if (!values.client || !values.title) {
+    throw new Error(`--client and --title are required.
+
+${USAGE}`);
+  }
+  if (values.date && !isValidISODate(values.date)) {
+    throw new Error(`--date must be YYYY-MM-DD, got "${values.date}".`);
+  }
+  const input = {
+    clientId: values.client,
+    title: values.title,
+    taskId: values.id,
+    link: values.link,
+    note: values.note,
+    date: values.date
+  };
+  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.");
+  }
+  return run(repo, input, !!values["dry-run"]);
+}
+async function run(repo, input, dryRun) {
+  const git = (...args) => execFileSync("git", ["-C", repo, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  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 { result, changed } = await applyToClone(repo, input);
+    if (changed.length === 0) {
+      console.log(describe(result, input, "nothing new to log"));
+      return;
+    }
+    if (dryRun) {
+      git("add", "--intent-to-add", "--", ...changed);
+      console.log(git("--no-pager", "diff", "--", ...changed));
+      git("reset", "--quiet", "--hard", "HEAD");
+      console.log(describe(result, input, "dry run, nothing committed"));
+      return;
+    }
+    git("add", "--", ...changed);
+    git("commit", "--quiet", "-m", `chore: worklog sync ${today()}`);
+    try {
+      git("push", "--quiet");
+      console.log(describe(result, input, `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 logged.", { cause: err });
+      }
+      if (attempt >= PUSH_ATTEMPTS) {
+        throw new Error(`Push rejected ${PUSH_ATTEMPTS} times; nothing was logged.`, { cause: err });
+      }
+      git("fetch", "--quiet");
+      git("reset", "--quiet", "--hard", "@{u}");
+    }
+  }
+}
+async function applyToClone(repo, input) {
+  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");
+  const result = await logWork(store, input);
+  const changed = [...fm.dirty].filter((path) => fm.text.has(path));
+  for (const path of changed) {
+    mkdirSync(dirname(join(repo, path)), { recursive: true });
+    writeFileSync(join(repo, path), fm.text.get(path) ?? "");
+  }
+  return { result, 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 describe({ task, created, markedWorked, noteAdded }, input, outcome) {
+  const what = [
+    created ? "created" : "found",
+    markedWorked ? `marked worked ${input.date ?? today()}` : void 0,
+    noteAdded ? "note added" : void 0
+  ].filter(Boolean);
+  return `${task.id} "${task.title}" (${task.sourceFile}): ${what.join(", ")} \u2014 ${outcome}`;
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});