@estruyf/worklog-cli 0.1.0 → 0.2.1

package/dist/worklog.js

@@ -101,6 +101,216 @@ function isTaskHeading(lines, index) {
   return false;
 }
 
+// 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 H22 = /^##\s+(.*)$/;
+var META2 = /^-\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 formatDuration(minutes) {
+  const h = Math.floor(minutes / 60);
+  const m = minutes % 60;
+  if (h === 0) {
+    return `${m}m`;
+  }
+  return m === 0 ? `${h}h` : `${h}h${m}m`;
+}
+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: (H22.exec(lines[0])?.[1] ?? "").trim(),
+    date: "",
+    people: [],
+    notes: "",
+    actions: [],
+    sourceFile,
+    sourceLine: line
+  };
+  let i = 1;
+  for (; i < lines.length; i++) {
+    const meta = META2.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/util/date.ts
 function today() {
   return toISODate(/* @__PURE__ */ new Date());
@@ -111,6 +321,9 @@ function toISODate(d) {
   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");
@@ -379,6 +592,10 @@ function firstOccurrence(rec, from) {
   }
   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) {
@@ -474,8 +691,8 @@ function rollToWeekday(iso, weekdays) {
 
 // src/parser/taskParser.ts
 var H1 = /^#\s+(.*)$/;
-var H22 = /^##\s+(.*)$/;
-var META2 = /^-\s+([A-Za-z][\w-]*)\s*:\s*(.*)$/;
+var H23 = /^##\s+(.*)$/;
+var META3 = /^-\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*$/;
@@ -511,6 +728,7 @@ function parseTaskFile(content, sourceFile, clientId) {
       lastDone: t.lastDone,
       repeatOf: t.repeatOf,
       workedOn: t.workedOn,
+      workedTime: t.workedTime,
       tags: t.tags,
       checklist,
       prompts,
@@ -522,7 +740,7 @@ function parseTaskFile(content, sourceFile, clientId) {
   };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    const h2 = isTaskHeading(lines, i) ? H22.exec(line) : null;
+    const h2 = isTaskHeading(lines, i) ? H23.exec(line) : null;
     if (h2) {
       flush();
       current = {
@@ -541,7 +759,7 @@ function parseTaskFile(content, sourceFile, clientId) {
       continue;
     }
     if (inMeta) {
-      const meta = META2.exec(line);
+      const meta = META3.exec(line);
       if (meta) {
         applyMeta(current.task, meta[1].toLowerCase(), meta[2].trim());
         continue;
@@ -648,7 +866,16 @@ function applyMeta(task, key, value) {
       if (!value) {
         break;
       }
-      const dates = value.split(/[\s,]+/).map((d) => d.trim()).filter(Boolean);
+      const dates = [];
+      for (const token of value.split(/[\s,]+/).filter(Boolean)) {
+        const minutes = /[hm]/i.test(token) ? parseDuration(token) : void 0;
+        const date = dates[dates.length - 1];
+        if (minutes !== void 0 && date) {
+          task.workedTime = { ...task.workedTime, [date]: minutes };
+        } else {
+          dates.push(token);
+        }
+      }
       if (dates.length === 0) {
         break;
       }
@@ -844,7 +1071,8 @@ function serializeTask(task, clientId) {
     out.push(`- repeatOf: ${task.repeatOf}`);
   }
   for (const worked of task.workedOn ?? []) {
-    out.push(`- worked: ${worked}`);
+    const minutes = task.workedTime?.[worked];
+    out.push(`- worked: ${worked}${minutes ? ` ${formatDuration(minutes)}` : ""}`);
   }
   if (task.tags && task.tags.length) {
     out.push(`- tags: ${task.tags.join(", ")}`);
@@ -896,6 +1124,13 @@ function parseWorklogFile(content, sourceFile) {
   }
   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]*$/;
@@ -936,7 +1171,7 @@ function bodyOf(lines) {
 // src/parser/checklistParser.ts
 var ITEM = /^(\s*)([-*+])\s+\[([ xX])\]\s?(.*)$/;
 var H12 = /^#[ \t]+(.*)$/;
-var H23 = /^##[ \t]+(.*)$/;
+var H24 = /^##[ \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/);
@@ -954,7 +1189,7 @@ function parseChecklistFile(content, sourceFile, id) {
       });
       continue;
     }
-    const h2 = H23.exec(line);
+    const h2 = H24.exec(line);
     if (h2) {
       sections.push({ title: h2[1].trim(), line: i, items: [] });
       continue;
@@ -979,219 +1214,17 @@ function parseChecklistFile(content, sourceFile, id) {
   };
 }
 
-// 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;
+// 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 = [];
@@ -1202,14 +1235,14 @@ function normalizeStatuses(input) {
     }
     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)) {
+    const label2 = typeof candidate.label === "string" ? candidate.label.trim() : "";
+    if (!id || !label2 || seen.has(id)) {
       continue;
     }
     seen.add(id);
     defs.push({
       id,
-      label: label.slice(0, MAX_STATUS_LABEL),
+      label: label2.slice(0, MAX_STATUS_LABEL),
       terminal: candidate.terminal === true || void 0,
       color: parseStatusColor(candidate.color)
     });
@@ -1230,6 +1263,12 @@ function normalizeStatuses(input) {
     { ...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";
 }
@@ -1400,8 +1439,8 @@ function parseLinks(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 } : {} };
+    const label2 = typeof l.label === "string" ? l.label.trim() : "";
+    return { url: l.url.trim(), ...label2 ? { label: label2 } : {} };
   });
 }
 function parseClientLinks(value) {
@@ -1590,11 +1629,72 @@ function dirName(path) {
   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()) {
@@ -1718,22 +1818,14 @@ 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/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) {
@@ -1761,6 +1853,21 @@ async function appendTaskBlock(ws, client, block) {
   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 {
@@ -1770,9 +1877,37 @@ ${block}
 }
 
 // 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) {
@@ -1789,14 +1924,36 @@ async function toggleTaskWorkedOn(store, taskId, date) {
     existing.delete(date);
   }
   const workedOn = [...existing].sort();
+  const workedTime = marking ? task.workedTime : withoutDay(task.workedTime, date);
   const wip = marking && !isClosed(task) ? inProgressStatusId(store.getConfig().statuses) : void 0;
   await updateInPlace(store, task, (t) => ({
     ...t,
     workedOn,
+    workedTime,
     status: wip ?? t.status
   }));
   await store.rebuild("toggleWorked");
-  return { ...task, workedOn, status: wip ?? task.status };
+  return { ...task, workedOn, workedTime, status: wip ?? task.status };
+}
+async function setTaskWorkedTime(store, taskId, date, minutes) {
+  let task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  if (minutes && !(task.workedOn ?? []).includes(date)) {
+    task = await toggleTaskWorkedOn(store, taskId, date);
+  }
+  const workedTime = minutes ? { ...task.workedTime, [date]: minutes } : withoutDay(task.workedTime, date);
+  await updateInPlace(store, task, (t) => ({ ...t, workedTime }));
+  await store.rebuild("setWorkedTime");
+  return { ...task, workedTime };
+}
+function withoutDay(time, date) {
+  if (!time || !(date in time)) {
+    return time;
+  }
+  const { [date]: _gone, ...rest } = time;
+  return Object.keys(rest).length ? rest : void 0;
 }
 async function addTaskNote(store, taskId, text) {
   const task = store.db.getTask(taskId);
@@ -1815,6 +1972,283 @@ async function addTaskNote(store, taskId, text) {
   await store.rebuild("addNote");
   return store.db.getTask(taskId) ?? task;
 }
+async function deleteTaskNote(store, taskId, index) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  await updateInPlace(store, task, (t) => {
+    const notes = [...t.notes ?? []];
+    if (index >= 0 && index < notes.length) {
+      notes.splice(index, 1);
+    }
+    return { ...t, notes };
+  });
+  await store.rebuild("deleteNote");
+  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,
+    workedTime: 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,
+    workedTime: snapshot.workedTime
+  }));
+  await store.rebuild("undoOccurrence");
+  return store.db.getTask(template.id) ?? template;
+}
+async function setTaskRecurrence(store, taskId, repeat) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  if (task.completed) {
+    throw new Error("Only open tasks can repeat.");
+  }
+  await updateInPlace(
+    store,
+    task,
+    (t) => withSeededDue({
+      ...t,
+      repeat,
+      lastDone: repeat ? t.lastDone : void 0
+    })
+  );
+  await store.rebuild("setRecurrence");
+  return store.db.getTask(taskId) ?? task;
+}
+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);
@@ -1892,12 +2326,16 @@ async function logWork(store, input) {
   if (markedWorked) {
     task = await toggleTaskWorkedOn(store, task.id, date);
   }
+  const timeSet = input.minutes === null ? !!task.workedTime?.[date] : !!input.minutes && task.workedTime?.[date] !== input.minutes;
+  if (timeSet) {
+    task = await setTaskWorkedTime(store, task.id, date, input.minutes ?? void 0);
+  }
   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 };
+  return { task: store.db.getTask(task.id) ?? task, created, markedWorked, timeSet, noteAdded };
 }
 function findTask(store, input) {
   if (input.taskId) {
@@ -1917,22 +2355,374 @@ 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.repeat !== void 0) {
+    const next = edit.repeat === null ? void 0 : { ...readRecurrence(edit.repeat), anchor: task.repeat?.anchor ?? "schedule", until: task.repeat?.until };
+    if ((next && formatRecurrence(next)) !== (task.repeat && formatRecurrence(task.repeat))) {
+      task = await setTaskRecurrence(store, task.id, next);
+      changed.push("repeat");
+    }
+  }
+  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 };
+}
+async function unlogWork(store, ref, input) {
+  let task = requireTask(store, ref, { includeClosed: true });
+  const unmarked = !!input.date && (task.workedOn ?? []).includes(input.date);
+  if (input.date && unmarked) {
+    task = await toggleTaskWorkedOn(store, task.id, input.date);
+  }
+  const note = input.note?.trim();
+  const index = note ? (task.notes ?? []).map((n) => n.text).lastIndexOf(note) : -1;
+  if (index >= 0) {
+    task = await deleteTaskNote(store, task.id, index);
+  }
+  return { task: store.db.getTask(task.id) ?? task, unmarked, noteRemoved: index >= 0 };
+}
+function readRecurrence(text) {
+  const rule = parseRecurrence(text);
+  if (!rule) {
+    throw new Error(
+      `Can't read the repeat "${text}". Use daily, weekdays, every 3 days, weekly on mon,thu, monthly on 15, monthly on last or yearly on 03-14.`
+    );
+  }
+  return rule;
+}
+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 repeat = input.repeat ? readRecurrence(input.repeat) : void 0;
+  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,
+    repeat
+  });
+  return { task: store.db.getTask(task.id) ?? task, created: true };
+}
+
+// src/services/listTasks.ts
+function listTasks(store, filter = {}) {
+  const tags = (filter.tags ?? []).map((t) => t.trim().toLowerCase()).filter(Boolean);
+  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) => tags.every((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 USAGE = `Usage: worklog log --client <id> --title <title> [options]
+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), records the time spent and adds the note.
+  unlog   Undoes a log: takes a day worked off a task, removes a 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.
 
-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.
+Every command:
+  --repo <path>         timesheet clone (default: $WORKLOG_REPO)
+  --client <id>         client id from .worklog/config.json; "todos" is the
+                        general to-do list
 
-  --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`;
+Naming a task (log, unlog, 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)
+  --time <duration>     time spent on the task that day: 1h, 45m, 1h30m, or
+                        none to clear it. Sets the day's time, it doesn't add.
+                        A record only: billed hours stay with "hours"
+
+unlog (at least one of):
+  --date <date>         take this day worked off the task, with its time
+  --note <text>         remove the note with exactly this text
+
+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
+  --repeat <rule>       daily, weekdays, every 3 days, weekly on mon,thu,
+                        monthly on 15, monthly on last, yearly on 03-14
+
+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
+  --repeat <rule|none>  a new repeat rule (as for add), or none to stop it
+
+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; repeat it for tasks with all
+  --json                print JSON instead of one line per task, with the
+                        days worked and the minutes per day
+
+log, unlog, add, update, done, hours:
+  --dry-run             show the change, commit nothing`;
+var OPTIONS = {
+  log: ["client", "id", "link", "title", "note", "date", "time", "dry-run"],
+  unlog: ["client", "id", "link", "title", "date", "note", "dry-run"],
+  add: ["client", "link", "title", "due", "priority", "description", "tag", "parent", "repeat", "dry-run"],
+  update: [
+    "client",
+    "id",
+    "link",
+    "title",
+    "rename",
+    "due",
+    "priority",
+    "description",
+    "status",
+    "tag",
+    "untag",
+    "parent",
+    "repeat",
+    "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".`,
+  time: `Time on a task is "worklog log --time"; a client's hours for the day are "worklog hours --hours".`,
+  due: "The day worked is --date; --due is when a to-do is due."
+};
 async function main() {
   const { values, positionals } = parseArgs({
     allowPositionals: true,
@@ -1943,6 +2733,20 @@ async function main() {
       id: { type: "string" },
       note: { type: "string" },
       date: { type: "string" },
+      time: { 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" },
+      repeat: { type: "string" },
+      event: { type: "string" },
+      hours: { type: "string" },
+      json: { type: "boolean" },
       repo: { type: "string" },
       "dry-run": { type: "boolean" },
       help: { type: "boolean", short: "h" }
@@ -1952,35 +2756,140 @@ async function main() {
     console.log(USAGE);
     return;
   }
-  if (positionals[0] !== "log" || positionals.length > 1) {
+  const command = positionals[0];
+  if (!(command in OPTIONS) || positionals.length > 1) {
     throw new Error(`Unknown command "${positionals.join(" ")}".
 
 ${USAGE}`);
   }
-  if (!values.client || !values.title) {
-    throw new Error(`--client and --title are required.
+  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}`);
   }
-  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
-  };
+  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.");
   }
-  return run(repo, input, !!values["dry-run"]);
+  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"]);
 }
-async function run(repo, input, dryRun) {
-  const git = (...args) => execFileSync("git", ["-C", repo, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+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 time = values.time;
+  if (typeof time === "string" && time !== NONE && !(/[hm]/i.test(time) && parseDuration(time))) {
+    throw new Error(`--time must be a duration like 1h, 45m or 1h30m, or none, got "${time}".`);
+  }
+  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 time = str("time");
+      const input = {
+        clientId,
+        title,
+        taskId: ref.taskId,
+        link: ref.link,
+        note: str("note"),
+        date: str("date"),
+        minutes: time === NONE ? null : time ? parseDuration(time) : void 0
+      };
+      return async (store) => describeLog(await logWork(store, input), input);
+    }
+    case "unlog": {
+      requireRef(ref);
+      const input = { date: str("date"), note: str("note") };
+      if (!input.date && !input.note) {
+        throw new Error("Nothing to take off: pass --date, --note or both.");
+      }
+      return async (store) => describeUnlog(await unlogWork(store, ref, 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"),
+        repeat: str("repeat")
+      };
+      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")),
+        repeat: orNull(str("repeat"))
+      };
+      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, --repeat.`);
+      }
+      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.`);
   }
@@ -1990,39 +2899,106 @@ async function run(repo, input, dryRun) {
   }
   git("merge", "--ff-only", "--quiet", "@{u}");
   for (let attempt = 1; ; attempt++) {
-    const { result, changed } = await applyToClone(repo, input);
+    const { line, changed } = await applyToClone(repo, edit);
     if (changed.length === 0) {
-      console.log(describe(result, input, "nothing new to log"));
+      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(describe(result, input, "dry run, nothing committed"));
+      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(describe(result, input, `pushed ${git("rev-parse", "--short", "HEAD")}`));
+      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 logged.", { cause: err });
+        throw new Error("Push failed; nothing was written.", { cause: err });
       }
       if (attempt >= PUSH_ATTEMPTS) {
-        throw new Error(`Push rejected ${PUSH_ATTEMPTS} times; nothing was logged.`, { cause: err });
+        throw new Error(`Push rejected ${PUSH_ATTEMPTS} times; nothing was written.`, { cause: err });
       }
       git("fetch", "--quiet");
       git("reset", "--quiet", "--hard", "@{u}");
     }
   }
 }
-async function applyToClone(repo, input) {
+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"],
+    tags: values.tag
+  });
+  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,
+    worked: t.workedOn ?? [],
+    minutes: t.workedTime ?? {},
+    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)) {
@@ -2033,24 +3009,63 @@ async function applyToClone(repo, input) {
   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));
+  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 { result, changed };
+  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 describe({ task, created, markedWorked, noteAdded }, input, outcome) {
+function label(task) {
+  return `${task.id} "${task.title}" (${task.sourceFile})`;
+}
+function describeLog({ task, created, markedWorked, timeSet, noteAdded }, input) {
   const what = [
     created ? "created" : "found",
     markedWorked ? `marked worked ${input.date ?? today()}` : void 0,
+    timeSet ? input.minutes ? `time ${formatDuration(input.minutes)}` : "time cleared" : void 0,
     noteAdded ? "note added" : void 0
   ].filter(Boolean);
-  return `${task.id} "${task.title}" (${task.sourceFile}): ${what.join(", ")} \u2014 ${outcome}`;
+  return `${label(task)}: ${what.join(", ")}`;
+}
+function describeUnlog({ task, unmarked, noteRemoved }, input) {
+  const what = [
+    input.date ? unmarked ? `took ${input.date} off` : `${input.date} wasn't marked worked` : void 0,
+    input.note ? noteRemoved ? "note removed" : "no note with that text" : 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,
+    task.repeat ? `repeats ${formatRecurrence(task.repeat)}` : 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));