@estruyf/worklog-cli 0.1.0 → 0.2.0

package/README.md

@@ -1,18 +1,30 @@
 # @estruyf/worklog-cli
 
-Log work on a task in your [Worklog](https://github.com/estruyf/worklog-web) timesheet repo with one
-command — made for AI agents that finish a piece of work and should leave a trace of it on your
-timesheet. The next time you open Worklog, the task is there, marked as worked.
+Work with your [Worklog](https://github.com/estruyf/worklog-web) timesheet repo from the command line —
+made for AI agents. Log the work they finished, add to-dos with a due date and priority, change or
+close tasks, list what's open, and set the hours worked on a day. The next time you open Worklog, it's all there.
 
 ```bash
 npx @estruyf/worklog-cli log --client acme --title "Fix the mobile picker" \
   --link https://github.com/acme/app/issues/12 --note "Widened the tap targets"
+
+npx @estruyf/worklog-cli add --client acme --title "Email Sam about the workshop" \
+  --due 2026-11-13 --priority high --description "Ask whether it becomes a roundtable or a session"
+
+npx @estruyf/worklog-cli update --id t_469p6i --due 2026-11-20
+npx @estruyf/worklog-cli done --id t_469p6i
+npx @estruyf/worklog-cli list --due-by 2026-11-30
+npx @estruyf/worklog-cli hours --client acme --hours 4 --note "Picker fixes"
 ```
 
 It edits a **local clone of your timesheet repo** and pushes with your own git credentials. It never
 talks to the Worklog site, so there is no token to set up.
 
-## Options
+Every command takes `--repo` (the clone; defaults to `$WORKLOG_REPO`), and every command that writes
+takes `--dry-run` (print the diff, commit nothing). Running the same command twice changes nothing.
+Each command refuses options it doesn't have, so a to-do's due date can never end up as a day worked.
+
+## `log` — work done
 
 | Option | Meaning |
 | --- | --- |
@@ -22,16 +34,82 @@ talks to the Worklog site, so there is no token to set up.
 | `--id` | Log on this exact task id instead. |
 | `--note` | Progress note added under the task's `### Notes`. |
 | `--date` | The day worked, `YYYY-MM-DD`. Defaults to today. |
-| `--repo` | Path to the clone. Defaults to `$WORKLOG_REPO`. |
-| `--dry-run` | Print the diff, commit nothing. |
 
 The task is matched by `--id`, then `--link`, then an **open task of the same title** for that
 client — so a task you typed into the app yourself is picked up rather than duplicated. With no match
-it is created. Running the same command twice changes nothing.
+it is created.
+
+## `add` — a to-do
+
+Creates an **open task**: nothing is marked worked and no note is written.
+
+| Option | Meaning |
+| --- | --- |
+| `--title` | The task's title. Required. |
+| `--client` | Client id. Leave it out for the general to-do list, the one that belongs to no client. |
+| `--due` | The day the task is due, `YYYY-MM-DD`. |
+| `--priority` | `urgent`, `high`, `normal` or `low`. Defaults to normal. |
+| `--description` | What the task is about, written under its fields. |
+| `--tag` | A tag. Repeat it for several. |
+| `--parent` | A task id, making the new task its subtask. |
+| `--link` | Issue or ticket url. |
+
+An open task with the same link or title is left as it is rather than duplicated.
+
+## `update` — change a task
+
+Name the task with `--id`, `--link` or `--title` (an open task's exact title; add `--client` when
+several clients have one), then pass only what changes:
+
+| Option | Meaning |
+| --- | --- |
+| `--rename` | A new title. |
+| `--due` | A new due date, or `none` to clear it. |
+| `--priority` | A new priority; `normal` clears it. |
+| `--description` | A new description; `""` clears it. |
+| `--status` | A status id from `.worklog/config.json`. A closing one closes the task. |
+| `--tag` / `--untag` | Add or remove a tag. Repeatable. |
+| `--parent` | Move it under this task id, or `none` to make it top-level. |
+
+A title that matches open tasks of several clients is refused, with their ids, rather than guessed.
+
+## `done` — close a task
+
+Named like `update`. The task moves to the archive with its subtasks, as when you close it in the app.
+A recurring task rolls on to its next occurrence instead.
+
+## `list` — what's open
+
+Read-only: it catches up with the remote first, and prints one tab-separated line per open task (id,
+due, priority, client, status, title), soonest due first.
+
+| Option | Meaning |
+| --- | --- |
+| `--client` | Only this client's tasks; `todos` for the general to-do list. |
+| `--due-by` | Only tasks due on or before this day. |
+| `--tag` | Only tasks with this tag. |
+| `--json` | Print JSON instead, with descriptions, tags and links. |
+
+## `hours` — time worked
+
+Time is tracked per client per day, as in the app's day editor, with the same rules: one line per
+client per day, `full` and `half` follow your working day (`hoursPerDay`), the general to-do list has
+no hours and an archived client is refused.
+
+| Option | Meaning |
+| --- | --- |
+| `--client` | The client the time is for. Or… |
+| `--event` | …a day off: `vacation`, `public-holiday`, `out-of-office`, `conference`, `sick` or `other`. |
+| `--hours` | `full`, `half` or a number of hours. **Sets** the day's total for that client; `0` removes it. |
+| `--date` | The day, `YYYY-MM-DD`. Defaults to today. |
+| `--note` | What the time went to. Left out, the note already there is kept. |
+
+Without `--hours` it is read-only and prints what's logged that day, and the total against your
+working day.
 
 ## Requirements
 
 - Node 20 or newer, and git.
 - A clone of your timesheet repo with no uncommitted changes and no unpushed commits — when its push
   loses a race with the app, the CLI resets the clone to the remote and replays its edit on top.
-- Hours are not logged: it records *that* you worked on a task, not for how long.
+- `log` records *that* you worked on a task, not for how long; hours are `hours`, per client per day.

package/dist/worklog.js

@@ -111,6 +111,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 +382,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) {
@@ -896,6 +903,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]*$/;
@@ -1202,14 +1216,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 +1244,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 +1420,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 +1610,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 +1799,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 +1834,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 +1858,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) {
@@ -1815,6 +1931,246 @@ async function addTaskNote(store, taskId, text) {
   await store.rebuild("addNote");
   return store.db.getTask(taskId) ?? task;
 }
+async function closeTaskById(store, taskId, completedDate = today()) {
+  const terminal = terminalStatusId(store.getConfig().statuses);
+  return closeCascade(store, taskId, terminal, completedDate);
+}
+async function closeCascade(store, taskId, statusId, completedDate, endSeries = false) {
+  const root = store.db.getTask(taskId);
+  if (!root) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  const openDescendants = collectDescendants(store, taskId).filter(
+    (t) => !isClosed(t)
+  );
+  for (const child of openDescendants) {
+    await closeOne(store, child, statusId, completedDate, endSeries);
+  }
+  const closed = await closeOne(store, root, statusId, completedDate, endSeries);
+  await store.rebuild("closeTask");
+  return closed;
+}
+async function closeOne(store, task, statusId, completedDate, endSeries = false) {
+  const clientId = task.clientIds[0];
+  const clientName = store.db.getClients().find((c) => c.id === clientId)?.name ?? clientId;
+  const clientUri = store.ws.clientFile(clientId);
+  const content = await readText(clientUri);
+  if (content === void 0) {
+    throw new Error(`Could not read ${clientId}.md to close "${task.title}".`);
+  }
+  const extracted = extractBlock(content, task.id);
+  if (!extracted) {
+    throw new Error(`Could not locate task ${task.id} in ${clientId}.md.`);
+  }
+  const source = withSeededDue(
+    parseTaskFile(extracted.block, clientUri, clientId).tasks[0] ?? task
+  );
+  if (source.repeat && !endSeries) {
+    const nextDue = nextDueAfterCompletion(
+      source.repeat,
+      source.due,
+      completedDate
+    );
+    if (nextDue) {
+      return rollOccurrence(store, {
+        source,
+        clientId,
+        clientName,
+        clientUri,
+        content,
+        statusId,
+        completedDate,
+        nextDue
+      });
+    }
+  }
+  const closed = {
+    ...source,
+    status: statusId,
+    completed: completedDate
+  };
+  await writeText(clientUri, extracted.remainder);
+  await appendArchiveBlock(
+    store.ws,
+    clientId,
+    clientName,
+    monthOf(closed.completed),
+    serializeTask(closed, clientId)
+  );
+  return closed;
+}
+async function rollOccurrence(store, args) {
+  const { source, clientId, clientName, clientUri, content } = args;
+  const snapshot = {
+    ...source,
+    id: newTaskId(),
+    status: args.statusId,
+    completed: args.completedDate,
+    repeat: void 0,
+    lastDone: void 0,
+    repeatOf: source.id
+  };
+  const live = {
+    ...source,
+    status: openStatusId(store.getConfig().statuses),
+    due: args.nextDue,
+    lastDone: args.completedDate,
+    completed: void 0,
+    notes: void 0,
+    // The queue is the plan and comes along; the prompts that ran belong to the
+    // occurrence that ran them and stay on its snapshot, or a weekly task would
+    // carry every prompt it ever ran into every future week.
+    prompts: queuedPrompts(source.prompts),
+    // Same reasoning one step further: the steps are the plan for the series and
+    // come along, but unticked — the ticks belong to the occurrence that earned
+    // them and stay on its snapshot.
+    checklist: untickedChecklist(source.checklist),
+    workedOn: void 0
+  };
+  const replaced = replaceBlock(
+    content,
+    source.id,
+    serializeTask(live, clientId)
+  );
+  if (replaced === void 0) {
+    throw new Error(`Could not locate task ${source.id} to roll forward.`);
+  }
+  await writeText(clientUri, replaced.replace(/\s*$/, "") + "\n");
+  await appendArchiveBlock(
+    store.ws,
+    clientId,
+    clientName,
+    monthOf(args.completedDate),
+    serializeTask(snapshot, clientId)
+  );
+  return live;
+}
+function queuedPrompts(prompts) {
+  const queued = (prompts ?? []).filter((p) => !p.ran);
+  return queued.length ? queued : void 0;
+}
+function untickedChecklist(checklist) {
+  return checklist?.length ? checklist.map((i) => ({ ...i, done: false })) : void 0;
+}
+async function reopenTask(store, taskId, statusId) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  if (task.repeatOf) {
+    const template = store.db.getTask(task.repeatOf);
+    if (template?.repeat) {
+      return undoOccurrence(store, task, template, statusId);
+    }
+  }
+  const clientId = task.clientIds[0];
+  const client = store.db.getClients().find((c) => c.id === clientId);
+  const archiveUri = task.sourceFile;
+  const content = await readText(archiveUri);
+  if (content === void 0) {
+    throw new Error(`Could not read the archive file for "${task.title}".`);
+  }
+  const extracted = extractBlock(content, task.id);
+  if (!extracted) {
+    throw new Error(`Could not locate task ${task.id} in the archive.`);
+  }
+  const parsed = parseTaskFile(extracted.block, archiveUri, clientId).tasks[0];
+  const reopened = {
+    ...parsed ?? task,
+    status: statusId,
+    completed: void 0
+  };
+  await writeText(archiveUri, extracted.remainder);
+  await appendTaskBlock(
+    store.ws,
+    client ?? { id: clientId, name: clientId },
+    serializeTask(reopened, clientId)
+  );
+  await store.rebuild("reopenTask");
+  return reopened;
+}
+async function undoOccurrence(store, snapshot, template, statusId) {
+  const archiveUri = snapshot.sourceFile;
+  const archiveContent = await readText(archiveUri);
+  if (archiveContent === void 0) {
+    throw new Error(`Could not read the archive file for "${snapshot.title}".`);
+  }
+  const extracted = extractBlock(archiveContent, snapshot.id);
+  if (!extracted) {
+    throw new Error(`Could not locate occurrence ${snapshot.id} in the archive.`);
+  }
+  const previous = store.db.occurrencesOf(template.id).find((o) => o.id !== snapshot.id && o.completed);
+  await writeText(archiveUri, extracted.remainder);
+  await updateInPlace(store, template, (t) => ({
+    ...t,
+    status: statusId,
+    due: snapshot.due,
+    lastDone: previous?.completed,
+    notes: snapshot.notes,
+    prompts: snapshot.prompts,
+    checklist: snapshot.checklist,
+    workedOn: snapshot.workedOn
+  }));
+  await store.rebuild("undoOccurrence");
+  return store.db.getTask(template.id) ?? template;
+}
+async function updateTask(store, taskId, fields) {
+  const task = store.db.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found.`);
+  }
+  const current = task.clientIds[0];
+  const target = fields.clientId && fields.clientId.trim() ? fields.clientId : current;
+  const apply = (t) => withSeededDue({
+    ...t,
+    title: fields.title !== void 0 ? fields.title.trim() || t.title : t.title,
+    // Passing the field at all is a decision about priority, so an unrecognised
+    // value clears it rather than leaving the old one standing.
+    priority: fields.priority !== void 0 ? writablePriority(fields.priority) : t.priority,
+    parentId: fields.parentId !== void 0 ? fields.parentId || void 0 : t.parentId,
+    links: fields.links !== void 0 ? parseLinks(fields.links) : t.links,
+    description: fields.description !== void 0 ? fields.description.trim() || void 0 : t.description,
+    due: fields.due !== void 0 ? fields.due.trim() || void 0 : t.due,
+    tags: fields.tags !== void 0 ? fields.tags.map((tag) => tag.trim()).filter(Boolean) : t.tags,
+    repeat: fields.repeat !== void 0 ? fields.repeat ?? void 0 : t.repeat,
+    // Dropping the rule drops the series' bookkeeping with it.
+    lastDone: fields.repeat === null ? void 0 : t.lastDone
+  });
+  if (target === current) {
+    await updateInPlace(store, task, apply);
+  } else {
+    const uri = task.sourceFile;
+    const content = await readText(uri);
+    if (content === void 0) {
+      throw new Error(`Could not read ${task.sourceFile}.`);
+    }
+    const extracted = extractBlock(content, task.id);
+    if (!extracted) {
+      throw new Error(`Could not locate task ${task.id}.`);
+    }
+    const parsed = parseTaskFile(extracted.block, uri, current).tasks[0] ?? task;
+    const moved = apply({ ...parsed, clientIds: [target] });
+    await writeText(uri, extracted.remainder);
+    if (moved.completed) {
+      const name = store.db.getClients().find((c) => c.id === target)?.name ?? target;
+      await appendArchiveBlock(
+        store.ws,
+        target,
+        name,
+        monthOf(moved.completed),
+        serializeTask(moved, target)
+      );
+    } else {
+      const client = store.db.getClients().find((c) => c.id === target) ?? {
+        id: target,
+        name: target
+      };
+      await appendTaskBlock(store.ws, client, serializeTask(moved, target));
+    }
+  }
+  await store.rebuild("updateTask");
+  return store.db.getTask(taskId) ?? task;
+}
 async function updateInPlace(store, task, mutate) {
   const uri = task.sourceFile;
   const content = await readText(uri);
@@ -1917,22 +2273,328 @@ function normalizeUrl(url) {
   return url.trim().replace(/\/+$/, "");
 }
 
+// src/services/editTask.ts
+function requireTask(store, ref, { includeClosed = false } = {}) {
+  if (ref.taskId) {
+    const byId = store.db.getTask(ref.taskId);
+    if (!byId) {
+      throw new Error(`Task ${ref.taskId} not found.`);
+    }
+    return byId;
+  }
+  if (!ref.link && !ref.title) {
+    throw new Error("Name the task with an id, a link or a title.");
+  }
+  const scoped = store.db.getAllTasks().filter((t) => !ref.clientId || t.clientIds.includes(ref.clientId));
+  const link = ref.link ? normalizeUrl(ref.link) : void 0;
+  const title = ref.title?.trim().toLowerCase();
+  const matches = scoped.filter(
+    (t) => link ? t.links.some((l) => normalizeUrl(l.url) === link) : t.title.trim().toLowerCase() === title
+  );
+  const named = link ? `linked to ${ref.link}` : `called "${ref.title}"`;
+  const open = matches.filter((t) => !t.completed);
+  if (open.length > 1) {
+    const list2 = open.map((t) => `${t.id} (${t.sourceFile})`).join(", ");
+    throw new Error(`Several open tasks are ${named}: ${list2}. Pass --id, or --client to narrow it down.`);
+  }
+  if (open.length === 1) {
+    return open[0];
+  }
+  const closed = matches.filter((t) => t.completed).sort((a, b) => (b.completed ?? "").localeCompare(a.completed ?? ""))[0];
+  if (includeClosed && closed) {
+    return closed;
+  }
+  throw new Error(`No open task is ${named}${ref.clientId ? ` for client "${ref.clientId}"` : ""}.`);
+}
+async function editTask(store, ref, edit) {
+  let task = requireTask(store, ref);
+  const fields = {};
+  const changed = [];
+  const title = edit.title?.trim();
+  if (title && title !== task.title) {
+    fields.title = title;
+    changed.push("title");
+  }
+  if (edit.due !== void 0 && (edit.due ?? void 0) !== task.due) {
+    fields.due = edit.due ?? "";
+    changed.push("due");
+  }
+  if (edit.priority !== void 0 && writablePriority(edit.priority) !== writablePriority(task.priority)) {
+    fields.priority = edit.priority;
+    changed.push("priority");
+  }
+  if (edit.description !== void 0 && (edit.description.trim() || void 0) !== task.description) {
+    fields.description = edit.description;
+    changed.push("description");
+  }
+  if (edit.addTags?.length || edit.removeTags?.length) {
+    const current = task.tags ?? [];
+    const remove = new Set((edit.removeTags ?? []).map((t) => t.trim().toLowerCase()));
+    const kept = current.filter((t) => !remove.has(t.toLowerCase()));
+    const added = (edit.addTags ?? []).map((t) => t.trim()).filter((t) => t && !kept.some((k) => k.toLowerCase() === t.toLowerCase()));
+    const tags = [...kept, ...added];
+    if (tags.join("\n") !== current.join("\n")) {
+      fields.tags = tags;
+      changed.push("tags");
+    }
+  }
+  if (edit.parentId !== void 0 && (edit.parentId ?? void 0) !== task.parentId) {
+    if (edit.parentId) {
+      requireParent(store, edit.parentId, task.id);
+    }
+    fields.parentId = edit.parentId ?? "";
+    changed.push("parent");
+  }
+  if (Object.keys(fields).length > 0) {
+    task = await updateTask(store, task.id, fields);
+  }
+  if (edit.status !== void 0 && edit.status !== task.status) {
+    const statuses = store.getConfig().statuses;
+    if (!statuses.some((s) => s.id === edit.status)) {
+      throw new Error(`Unknown status "${edit.status}". Known: ${statuses.map((s) => s.id).join(", ")}.`);
+    }
+    task = await setTaskStatus(store, task.id, edit.status);
+    changed.push("status");
+  }
+  return { task: store.db.getTask(task.id) ?? task, changed };
+}
+async function closeTask(store, ref) {
+  const task = requireTask(store, ref, { includeClosed: true });
+  if (task.completed || task.repeat && task.lastDone === today()) {
+    return { task, closed: false };
+  }
+  const closed = await closeTaskById(store, task.id);
+  return { task: store.db.getTask(task.id) ?? closed, closed: true };
+}
+function requireParent(store, parentId, childId) {
+  const parent = store.db.getTask(parentId);
+  if (!parent) {
+    throw new Error(`Parent task ${parentId} not found.`);
+  }
+  for (let p = parent; p; p = p.parentId ? store.db.getTask(p.parentId) : void 0) {
+    if (p.id === childId) {
+      throw new Error(`Task ${childId} can't go under ${parentId}: that is the task itself or one of its subtasks.`);
+    }
+  }
+  return parent;
+}
+
+// src/services/addTask.ts
+async function addTask(store, input) {
+  const existing = findTask(store, input);
+  if (existing) {
+    return { task: existing, created: false };
+  }
+  if (input.parentId) {
+    requireParent(store, input.parentId);
+  }
+  const task = await createTask(store, {
+    clientId: input.clientId,
+    title: input.title,
+    links: input.link ? [input.link] : void 0,
+    due: input.due,
+    priority: input.priority,
+    description: input.description,
+    tags: input.tags,
+    parentId: input.parentId
+  });
+  return { task: store.db.getTask(task.id) ?? task, created: true };
+}
+
+// src/services/listTasks.ts
+function listTasks(store, filter = {}) {
+  const tag = filter.tag?.trim().toLowerCase();
+  return store.db.getAllTasks().filter((t) => !t.completed).filter((t) => !filter.clientId || t.clientIds.includes(filter.clientId)).filter((t) => !filter.dueBy || !!t.due && t.due <= filter.dueBy).filter((t) => !tag || (t.tags ?? []).some((x) => x.toLowerCase() === tag)).sort(
+    (a, b) => (a.due ?? "\uFFFF").localeCompare(b.due ?? "\uFFFF") || priorityRank(a.priority) - priorityRank(b.priority) || (a.created ?? "").localeCompare(b.created ?? "")
+  );
+}
+
+// src/services/worklog.ts
+function withEntry(existing, month, date, clientId, hours, note) {
+  const line = serializeWorklogEntry({ date, clientId, hours, note });
+  if (existing === void 0 || existing.trim() === "") {
+    return `# Worklog ${month}
+
+${line}
+`;
+  }
+  const lines = existing.split(/\r?\n/);
+  const prefix = `- ${date} ${clientId} `;
+  const idx = lines.findIndex((l) => l.startsWith(prefix));
+  if (idx >= 0) {
+    lines[idx] = line;
+  } else {
+    let insertAt = lines.length;
+    while (insertAt > 0 && lines[insertAt - 1].trim() === "") {
+      insertAt--;
+    }
+    lines.splice(insertAt, 0, line);
+  }
+  return lines.join("\n").replace(/\s+$/, "") + "\n";
+}
+async function setWorklog(store, date, clientId, hours, note) {
+  if (!(hours > 0)) {
+    return removeWorklog(store, date, clientId);
+  }
+  const month = monthOf(date);
+  const uri = store.ws.worklogFile(month);
+  await ensureDir(store.ws.worklogDir);
+  const existing = await readText(uri);
+  await writeText(uri, withEntry(existing, month, date, clientId, hours, note));
+  await store.rebuild("setWorklog");
+}
+async function removeWorklog(store, date, clientId) {
+  const uri = store.ws.worklogFile(monthOf(date));
+  const existing = await readText(uri);
+  if (existing === void 0) {
+    return;
+  }
+  const prefix = `- ${date} ${clientId} `;
+  const lines = existing.split(/\r?\n/).filter((l) => !l.startsWith(prefix));
+  await writeText(uri, lines.join("\n").replace(/\s+$/, "") + "\n");
+  await store.rebuild("removeWorklog");
+}
+
+// src/services/logHours.ts
+async function logHours(store, input) {
+  const config = store.getConfig();
+  const date = input.date ?? today();
+  if (!!input.clientId === !!input.event) {
+    throw new Error("Name either a client or a day event.");
+  }
+  let target;
+  if (input.event) {
+    target = eventWorklogClientId(input.event);
+    if (!EVENT_TYPES.some((e) => e.id === eventTypeFromClientId(target))) {
+      throw new Error(`Unknown day event "${input.event}". Known: ${EVENT_TYPES.map((e) => e.id).join(", ")}.`);
+    }
+  } else {
+    target = input.clientId;
+    const reason = unloggableReason(store.db.getClients(), target);
+    if (reason) {
+      throw new Error(reason);
+    }
+  }
+  const hours = resolveHours(input.hours, config.hoursPerDay);
+  if (hours === void 0) {
+    throw new Error(`Hours must be full, half or a number, got "${input.hours}".`);
+  }
+  const previous = dayEntries(store, date).find((e) => e.clientId === target);
+  const note = input.note !== void 0 ? input.note.trim() || void 0 : previous?.note;
+  const changed = hours > 0 ? previous?.hours !== hours || previous?.note !== note : !!previous;
+  if (changed) {
+    await setWorklog(store, date, target, hours, note);
+  }
+  return {
+    target,
+    date,
+    hours,
+    previous,
+    changed,
+    dayTotal: roundHours(dayEntries(store, date).reduce((sum, e) => sum + e.hours, 0)),
+    hoursPerDay: config.hoursPerDay
+  };
+}
+function dayEntries(store, date) {
+  return store.db.getAllWorklog().filter((e) => e.date === date);
+}
+function targetLabel(store, target) {
+  if (isEventWorklogClientId(target)) {
+    return eventLabel(eventTypeFromClientId(target));
+  }
+  return store.db.getClients().find((c) => c.id === target)?.name ?? target;
+}
+
 // cli/worklog.ts
 var TEXT_PATH = /\.(md|json)$|\.worklog$/;
 var PUSH_ATTEMPTS = 3;
-var 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) and adds the note.
+  add     Something still to do: creates an open task. No day is marked worked.
+          Without --client it goes on the general to-do list.
+  update  Changes an existing task: due date, priority, description, ...
+  done    Closes a task. A recurring one rolls on to its next occurrence.
+  list    Prints the open tasks. Read-only.
+  hours   Sets the hours worked for a client (or a day event) on a day. Without
+          --hours it prints what's logged that day.
+
+All but list, and hours without --hours, commit and push to your timesheet repo.
+
+Every command:
+  --repo <path>         timesheet clone (default: $WORKLOG_REPO)
+  --client <id>         client id from .worklog/config.json; "todos" is the
+                        general to-do list
+
+Naming a task (log, update, done):
+  --id <t_xxxxxx>       this exact task
+  --link <url>          the task linked to this issue/ticket url
+  --title <title>       the open task with this title
+
+log --client <id> --title <title>:
+  --note <text>         progress note added to the task
+  --date <date>         day worked, YYYY-MM-DD (default: today)
 
-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.
+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
 
-  --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`;
+update:
+  --rename <title>      new title
+  --due <date|none>     new due date, or none to clear it
+  --priority <level>    new priority; normal clears it
+  --description <text>  new description; "" clears it
+  --status <id>         a status from .worklog/config.json
+  --tag <tag>           add a tag (repeatable)
+  --untag <tag>         remove a tag (repeatable)
+  --parent <id|none>    move it under this task, or none to make it top-level
+
+hours --client <id> | --event <type>:
+  --hours <amount>      full, half, or a number of hours; 0 removes the entry.
+                        Sets the day's total for that client, it doesn't add
+  --date <date>         the day, YYYY-MM-DD (default: today)
+  --note <text>         what the time went to (default: keep the note there)
+  --event <type>        ${EVENT_TYPES.map((e) => e.id).join(", ")}
+
+list:
+  --due-by <date>       only tasks due on or before this day
+  --tag <tag>           only tasks with this tag
+  --json                print JSON instead of one line per task
+
+log, add, update, done, hours:
+  --dry-run             show the change, commit nothing`;
+var OPTIONS = {
+  log: ["client", "id", "link", "title", "note", "date", "dry-run"],
+  add: ["client", "link", "title", "due", "priority", "description", "tag", "parent", "dry-run"],
+  update: [
+    "client",
+    "id",
+    "link",
+    "title",
+    "rename",
+    "due",
+    "priority",
+    "description",
+    "status",
+    "tag",
+    "untag",
+    "parent",
+    "dry-run"
+  ],
+  done: ["client", "id", "link", "title", "dry-run"],
+  list: ["client", "due-by", "tag", "json"],
+  hours: ["client", "event", "hours", "date", "note", "dry-run"]
+};
+var HINTS = {
+  date: `A to-do's date is --due; --date is the day worked, for "worklog log" and "worklog hours".`,
+  due: "The day worked is --date; --due is when a to-do is due."
+};
 async function main() {
   const { values, positionals } = parseArgs({
     allowPositionals: true,
@@ -1943,6 +2605,18 @@ async function main() {
       id: { type: "string" },
       note: { type: "string" },
       date: { type: "string" },
+      due: { type: "string" },
+      "due-by": { type: "string" },
+      priority: { type: "string" },
+      description: { type: "string" },
+      rename: { type: "string" },
+      status: { type: "string" },
+      tag: { type: "string", multiple: true },
+      untag: { type: "string", multiple: true },
+      parent: { type: "string" },
+      event: { type: "string" },
+      hours: { type: "string" },
+      json: { type: "boolean" },
       repo: { type: "string" },
       "dry-run": { type: "boolean" },
       help: { type: "boolean", short: "h" }
@@ -1952,35 +2626,117 @@ 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 priority = values.priority;
+  if (typeof priority === "string" && !PRIORITIES.some((p) => p.id === priority.trim().toLowerCase())) {
+    throw new Error(`--priority must be one of ${PRIORITIES.map((p) => p.id).join(", ")}, got "${priority}".`);
+  }
+}
+function toEdit(command, values) {
+  const str = (key) => values[key];
+  const list2 = (key) => values[key];
+  const ref = { taskId: str("id"), link: str("link"), title: str("title"), clientId: str("client") };
+  const orNull = (value) => value === NONE ? null : value;
+  switch (command) {
+    case "log": {
+      const clientId = str("client");
+      const title = str("title");
+      if (!clientId || !title) {
+        throw new Error(`--client and --title are required.
+
+${USAGE}`);
+      }
+      const input = { clientId, title, taskId: ref.taskId, link: ref.link, note: str("note"), date: str("date") };
+      return async (store) => describeLog(await logWork(store, input), input);
+    }
+    case "add": {
+      const title = str("title");
+      if (!title) {
+        throw new Error(`--title is required.
+
+${USAGE}`);
+      }
+      const input = {
+        clientId: str("client") ?? GENERAL_TODO_CLIENT_ID,
+        title,
+        link: ref.link,
+        due: str("due"),
+        priority: str("priority"),
+        description: str("description"),
+        tags: list2("tag"),
+        parentId: str("parent")
+      };
+      return async (store) => describeAdd(await addTask(store, input));
+    }
+    case "update": {
+      requireRef(ref);
+      const edit = {
+        title: str("rename"),
+        due: orNull(str("due")),
+        priority: str("priority"),
+        description: str("description"),
+        status: str("status"),
+        addTags: list2("tag"),
+        removeTags: list2("untag"),
+        parentId: orNull(str("parent"))
+      };
+      if (Object.values(edit).every((v) => v === void 0)) {
+        throw new Error(`Nothing to change: pass at least one of --rename, --due, --priority, --description, --status, --tag, --untag, --parent.`);
+      }
+      return async (store) => describeUpdate(await editTask(store, ref, edit));
+    }
+    case "hours": {
+      const input = { clientId: str("client"), event: str("event"), hours: str("hours") ?? "", note: str("note"), date: str("date") };
+      return async (store) => describeHours(store, await logHours(store, input));
+    }
+    default: {
+      requireRef(ref);
+      return async (store) => describeDone(await closeTask(store, ref));
+    }
+  }
+}
+function requireRef(ref) {
+  if (!ref.taskId && !ref.link && !ref.title) {
+    throw new Error(`Name the task with --id, --link or --title.
+
+${USAGE}`);
+  }
+}
+async function run(repo, edit, dryRun) {
+  const git = gitIn(repo);
   if (git("status", "--porcelain", "--untracked-files=no")) {
     throw new Error(`${repo} has uncommitted changes; commit or discard them first.`);
   }
@@ -1990,39 +2746,104 @@ 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"],
+    tag: values.tag?.[0]
+  });
+  if (values.json) {
+    console.log(JSON.stringify(tasks.map(toJson), null, 2));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("No open tasks match.");
+    return;
+  }
+  for (const t of tasks) {
+    console.log(
+      [t.id, t.due ?? "-", t.priority ?? "-", t.clientIds[0], t.status, t.title].join("	")
+    );
+  }
+}
+async function showDay(repo, date) {
+  catchUp(repo);
+  const { store } = await loadClone(repo);
+  const entries = dayEntries(store, date);
+  const total = entries.reduce((sum, e) => sum + e.hours, 0);
+  console.log(`${date}: ${total}h logged of ${store.getConfig().hoursPerDay}h`);
+  for (const e of entries) {
+    console.log(["", e.clientId, `${e.hours}h`, targetLabel(store, e.clientId), e.note ?? ""].join("	").trimEnd());
+  }
+}
+function toJson(t) {
+  return {
+    id: t.id,
+    title: t.title,
+    client: t.clientIds[0],
+    status: t.status,
+    priority: t.priority ?? "normal",
+    due: t.due ?? null,
+    tags: t.tags ?? [],
+    links: t.links.map((l) => l.url),
+    parent: t.parentId ?? null,
+    repeats: !!t.repeat,
+    created: t.created ?? null,
+    description: t.description ?? null,
+    file: t.sourceFile
+  };
+}
+function gitIn(repo) {
+  return (...args) => execFileSync("git", ["-C", repo, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+async function loadClone(repo) {
   const fm = new FileMap();
   for (const path of listFiles(repo)) {
     if (isWorklogPath(path) && TEXT_PATH.test(path)) {
@@ -2033,24 +2854,54 @@ 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, noteAdded }, input) {
   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}`;
+  return `${label(task)}: ${what.join(", ")}`;
+}
+function describeAdd({ task, created }) {
+  const what = [
+    created ? "created" : "already exists, left as is",
+    task.due ? `due ${task.due}` : void 0,
+    task.priority ? `priority ${task.priority}` : void 0
+  ].filter(Boolean);
+  return `${label(task)}: ${what.join(", ")}`;
+}
+function describeUpdate({ task, changed }) {
+  return `${label(task)}: ${changed.length ? `changed ${changed.join(", ")}` : "already up to date"}`;
+}
+function describeHours(store, r) {
+  const was = !r.previous ? "new" : r.previous.hours === r.hours && r.changed ? "note updated" : `was ${r.previous.hours}h`;
+  const what = r.hours > 0 ? `${r.hours}h (${was})` : r.previous ? `removed (was ${r.previous.hours}h)` : "nothing logged";
+  return `${targetLabel(store, r.target)} on ${r.date}: ${what}; day total ${r.dayTotal}h of ${r.hoursPerDay}h`;
+}
+function describeDone({ task, closed }) {
+  if (!closed) {
+    return `${label(task)}: ${task.completed ? `already closed on ${task.completed}` : `already done today, next due ${task.due}`}`;
+  }
+  return `${label(task)}: ${task.completed ? "closed" : `done, next due ${task.due}`}`;
 }
 main().catch((err) => {
   console.error(err instanceof Error ? err.message : String(err));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@estruyf/worklog-cli",
-  "version": "0.1.0",
-  "description": "Log work on a task in your Worklog timesheet repo from the command line or an AI agent.",
+  "version": "0.2.0",
+  "description": "Log work on a task, or add a to-do, in your Worklog timesheet repo from the command line or an AI agent.",
   "license": "MIT",
   "author": "Elio Struyf",
   "type": "module",